@seekprotocol/sdk 0.1.0 → 0.1.1

package/README.md

@@ -22,9 +22,10 @@ export default quest({
 });
 ```
 
-A quest is data: the SDK describes it, and Seek's server runs it. Test and
-submit it with [`@seekprotocol/cli`](https://www.npmjs.com/package/@seekprotocol/cli).
+Test and submit it with the `seek` command from
+[`@seekprotocol/cli`](https://www.npmjs.com/package/@seekprotocol/cli).
 
-Seek Protocol: https://www.seekprotocol.ai/en
+- Store Connect: https://storeconnect.seekprotocol.ai
+- Seek Protocol: https://www.seekprotocol.ai/en
 
 Copyright (c) 2026 Seek Protocol. Licensed under the Seek Protocol SDK License, see `LICENSE.md`.

package/assets.d.ts

@@ -1,50 +1,23 @@
-/**
- * What a minigame's files cost a phone: pixels in memory, seconds of sound,
- * and the bytes it loads before it can start.
- *
- * Megabytes say little about memory: a 5 MB PNG can be 8000 by 8000 pixels,
- * and once decoded that is 256 MB, which ends a WebView on an older phone
- * without a word. So images are measured by their pixels, read from the file
- * header without decoding anything, and sound by its length.
- *
- * Two levels, like the rest of Seek's checks: an `issue` means the game cannot
- * be submitted (`seek build`, Store Connect and the review all refuse it), an
- * `advice` is a tip that `seek test` prints and `seek optimize` can act on.
- * The same file runs in the CLI, the Workers and the Deno functions, so a
- * maker sees on their own laptop exactly what Seek will say.
- *
- * Plain JavaScript on bytes: no Node APIs, no DOM.
- */
-import { type GameIssue } from './games.js';
+import { type GameIssue } from "./games.js";
 export declare const ASSET_LIMITS: {
-    /** Longest side of an image. Above it the game is refused: phones cannot keep such a texture. */
     readonly imageMaxSide: 4096;
-    /** Longest side `seek optimize` scales down to, and above which `seek test` advises it. */
     readonly imageAdviseSide: 2048;
-    /** All images of a game decoded (width x height x 4 bytes), refused above this. */
     readonly decodedMaxBytes: number;
     readonly decodedAdviseBytes: number;
-    /** What index.html loads before the game can start (its scripts, styles, images and their imports). */
     readonly startMaxBytes: number;
     readonly startAdviseBytes: number;
-    /** A WAV file: uncompressed, so large ones are refused and any of size gets a tip. */
     readonly wavMaxBytes: number;
     readonly wavAdviseBytes: number;
-    /** One sound, in seconds. */
     readonly audioMaxSeconds: 600;
-    /** A PNG without transparency above this is probably a photo: JPEG or WebP is far smaller. */
     readonly opaquePngAdviseBytes: number;
-    /** A GIF above this: animated GIFs are heavy, WebP or a sprite sheet is lighter. */
     readonly gifAdviseBytes: number;
 };
-/** The store cover of a quest: what Store Connect accepts, and what the app shows at 16:9. */
 export declare const COVER_SPEC: {
     readonly maxBytes: number;
     readonly minWidth: 1280;
     readonly minHeight: 720;
     readonly maxWidth: 3840;
     readonly maxHeight: 2160;
-    /** Width divided by height, within 1%. */
     readonly ratio: number;
     readonly ratioTolerance: 0.01;
     readonly types: readonly string[];
@@ -52,19 +25,10 @@ export declare const COVER_SPEC: {
 export interface ImageSize {
     width: number;
     height: number;
-    /** PNG only: whether the image has an alpha channel (colour type 4 or 6, or a tRNS chunk). */
     alpha?: boolean;
 }
-/** An image's pixel size from its header, or null when it cannot be read (SVG has none: it is drawn, not decoded). */
 export declare function imageSize(path: string, bytes: Uint8Array): ImageSize | null;
-/** How long a sound file plays, in seconds, from its headers; null when that cannot be told. */
 export declare function audioSeconds(path: string, bytes: Uint8Array): number | null;
-/**
- * The files index.html needs before the game can call ready(): what it names
- * in src and href (links excepted), what those stylesheets import and use, and
- * the static imports of its scripts, followed through. Dynamic import() and
- * fetch() are not followed: that is how a game loads the rest later.
- */
 export declare function startFiles(files: ReadonlyMap<string, Uint8Array>): string[];
 export interface GameAdvice {
     path: string;
@@ -85,24 +49,18 @@ export interface GameAssetReport {
         seconds: number | null;
         bytes: number;
     }[];
-    /** All images decoded, in bytes. */
     decodedBytes: number;
-    /** What index.html loads before ready(). */
     start: {
         files: string[];
         bytes: number;
     };
-    /** The game cannot be submitted with these. */
     issues: GameIssue[];
-    /** Tips: `seek test` prints them, `seek optimize` acts on most. */
     advice: GameAdvice[];
 }
-/** Everything this file knows about a game's files, as issues and advice. */
 export declare function analyzeGameAssets(input: Iterable<{
     path: string;
     bytes: Uint8Array;
 }> | ReadonlyMap<string, Uint8Array>): GameAssetReport;
-/** Why a cover cannot be used, or null. Checked by its bytes, never by its name. */
 export declare function coverProblem(bytes: Uint8Array): {
     code: string;
     message: string;

package/builders.d.ts

@@ -1,25 +1,10 @@
-/**
- * The words a maker writes a quest in.
- *
- *   import { quest, step, zone, reward, t } from '@seekprotocol/sdk';
- *
- * Every builder returns plain data. Nothing here runs later: `seek build`
- * calls `compile` on what the quest file exports, and the JSON that comes out
- * is what Seek reviews and runs.
- */
-import type { Area, ArenaStep, ArriveStep, CatchStep, ChoiceStep, Place, PlayStep, Point, QuestDefinition, Reward, TalkStep, Text, WalkStep } from './types.js';
-/** Player-facing text, in English. Seek translates it into the other 30 languages. */
+import type { Area, ArenaStep, ArriveStep, CatchStep, ChoiceStep, Place, PlayStep, Point, QuestDefinition, Reward, TalkStep, Text, WalkStep } from "./types.js";
 export declare function t(en: string): Text;
-/** The quest itself. Returned unchanged; the type checks it as you write. */
 export declare function quest(definition: QuestDefinition): QuestDefinition;
 export declare const zone: {
-    /** Playable anywhere a player is. */
     anywhere(): Area;
-    /** A city or neighbourhood, as a centre and a radius. */
     circle(name: string, center: Point, radiusM: number): Area;
-    /** A city, with its centre and a radius in kilometres (10 by default). */
     city(name: string, center: Point, radiusKm?: number): Area;
-    /** A place a step points at: a landmark, a square, a park. */
     place(name: string, at: Point): Place;
 };
 type Common = {
@@ -68,7 +53,6 @@ export declare const reward: {
     card(card: string): Reward;
     cosmetic(item: string): Reward;
     boost(boost: string, count?: number): Reward;
-    /** A coin pot. Needs the `rewards.crypto` capability, which only Seek grants. */
     pool(coin: string, perPlayer: number, maxPlayers: number): Reward;
 };
 export {};

package/compile.d.ts

@@ -1,14 +1,5 @@
-/**
- * From a quest definition to the bundle Seek runs.
- *
- * Texts move into one table keyed by where they sit (`steps.bridge.title`),
- * which is what Seek translates; every `next` is resolved, so the server never
- * has to know the order steps were written in. The output is canonical JSON,
- * and its SHA-256 is the bundle's identity everywhere after this: in R2, in
- * the version row, in the pointer that makes it live.
- */
-import { type QuestBundle, type QuestDefinition } from './types.js';
-import { type Issue } from './validate.js';
+import { type QuestBundle, type QuestDefinition } from "./types.js";
+import { type Issue } from "./validate.js";
 export declare const VERSION_PATTERN: RegExp;
 export declare class QuestInvalidError extends Error {
     readonly issues: Issue[];
@@ -17,11 +8,8 @@ export declare class QuestInvalidError extends Error {
 export interface CompileOptions {
     version: string;
     build: number;
-    /** GameKit: the hash of each `play` step's game, from `packageGame`. Written to `manifest.games`. */
     games?: Record<string, string>;
 }
 export declare function compile(q: QuestDefinition, opts: CompileOptions): QuestBundle;
-/** JSON with sorted keys and no whitespace: the same bundle always gives the same bytes. */
 export declare function canonicalJson(value: unknown): string;
-/** The bundle's identity: SHA-256 of its canonical JSON, in hex. */
 export declare function bundleHash(bundle: QuestBundle): Promise<string>;

package/games.d.ts

@@ -1,12 +1,9 @@
-import { GAME_ID_PATTERN } from './types.js';
-import { type GameAssetReport } from './assets.js';
+import { GAME_ID_PATTERN } from "./types.js";
+import { type GameAssetReport } from "./assets.js";
 export { GAME_ID_PATTERN };
 export declare const GAME_FORMAT: 1;
-/** The id a game has on Seek's CDN and in launch tokens: `<gameId>-<16 hex of sha256(questId)>`. */
 export declare const GAME_APP_ID_PATTERN: RegExp;
-/** Where games are served from: `<appId>.play.seekprotocol.ai`. */
 export declare const GAME_HOST_SUFFIX = "play.seekprotocol.ai";
-/** The only origin a game may reach over the network. */
 export declare const GAME_PROXY_ORIGIN = "https://api.play.seekprotocol.ai";
 export declare const GAME_LIMITS: {
     readonly files: 200;
@@ -14,13 +11,10 @@ export declare const GAME_LIMITS: {
     readonly totalBytes: number;
     readonly pathLength: 120;
     readonly depth: 5;
-    /** One path segment: no hidden files, no `..`, nothing a shell or a URL treats specially. */
     readonly segment: RegExp;
-    /** Per player per game, through the proxy. */
     readonly storageBytes: number;
 };
-export type GameFileKind = 'html' | 'script' | 'style' | 'data' | 'image' | 'audio' | 'font';
-/** Every file type a game may carry, by extension. Anything else is refused. */
+export type GameFileKind = "html" | "script" | "style" | "data" | "image" | "audio" | "font";
 export declare const GAME_FILE_TYPES: Record<string, {
     type: string;
     kind: GameFileKind;
@@ -30,19 +24,14 @@ export declare const GAME_ENTRY = "index.html";
 export interface GameFile {
     path: string;
     size: number;
-    /** SHA-256 of the bytes, hex. */
     sha256: string;
-    /** The Content-Type it is served with, from `GAME_FILE_TYPES`. */
     type: string;
 }
-/** What `seek build` makes of `games/<id>/`, and what its hash is taken over. */
 export interface GameManifest {
     format: typeof GAME_FORMAT;
     id: string;
     entry: typeof GAME_ENTRY;
-    /** Sorted by path. */
     files: GameFile[];
-    /** All files together, in bytes. */
     size: number;
 }
 export interface GameIssue {
@@ -56,44 +45,29 @@ export declare const gameFileType: (path: string) => {
     kind: GameFileKind;
     text: boolean;
 } | undefined;
-/** Why a path cannot be in a game, or null when it can. */
 export declare function gamePathProblem(path: string): GameIssue | null;
-/** Whether the bytes are what the extension claims: text is UTF-8 without NUL, binaries carry their signature, nothing is an executable. */
 export declare function sniffGameFile(path: string, bytes: Uint8Array): GameIssue | null;
-/** Everything about a manifest that can be checked without the bytes. */
 export declare function validateGameManifest(m: unknown): GameIssue[];
-/** The game's identity: SHA-256 of its manifest's canonical JSON, hex. */
 export declare const gameHash: (m: GameManifest) => Promise<string>;
-/** Whether one file's bytes are what the manifest says. */
 export declare function verifyGameFile(f: GameFile, bytes: Uint8Array): Promise<GameIssue | null>;
 export interface PackagedGame {
     manifest: GameManifest;
     hash: string;
     issues: GameIssue[];
-    /** Pixels, sound and what loads before ready(): its issues are in `issues` too. */
     assets: GameAssetReport;
 }
-/** From the files of `games/<id>/` to a manifest and a hash. Issues mean the game cannot be submitted. */
 export declare function packageGame(id: string, files: {
     path: string;
     bytes: Uint8Array;
 }[]): Promise<PackagedGame>;
-/** The id a quest's game has on Seek's CDN: unique per quest, so two makers' `runner` never share a domain or a `sub`. */
 export declare function gameAppId(questId: string, gameId: string): Promise<string>;
 export declare const gameOrigin: (appId: string) => string;
 export interface GameFinding {
     path: string;
     line: number;
     code: string;
-    /** `fail`: the version cannot pass. `flag`: a person looks at it. */
-    severity: 'fail' | 'flag';
+    severity: "fail" | "flag";
     message: string;
     match: string;
 }
-/**
- * What a reviewer should know about one text file of a game. Remote URLs that
- * would load something fail (the CSP blocks them anyway, but a game that
- * relies on them is broken or trying something); remote URLs in plain text,
- * inline handlers and eval-like code are flagged for a person.
- */
 export declare function lintGameText(path: string, text: string, limit?: number): GameFinding[];

package/index.d.ts

@@ -1,10 +1,10 @@
-export * from './types.js';
-export * from './builders.js';
-export * from './validate.js';
-export * from './compile.js';
-export * from './sign.js';
-export * from './log.js';
-export * from './package.js';
-export * from './verify.js';
-export * from './games.js';
-export * from './assets.js';
+export * from "./types.js";
+export * from "./builders.js";
+export * from "./validate.js";
+export * from "./compile.js";
+export * from "./sign.js";
+export * from "./log.js";
+export * from "./package.js";
+export * from "./verify.js";
+export * from "./games.js";
+export * from "./assets.js";

package/log.d.ts

@@ -1,17 +1,7 @@
-/**
- * The transparency log: every signature Seek ever made, in order.
- *
- * Each entry's hash covers the entry before it, so the newest hash commits to
- * the whole history: change or drop one entry and every hash after it differs.
- * Supabase writes the log (`platform__log_append`, which must build the same
- * string as `logEntryHash`); anyone holding the entries can check it here, and
- * compare the newest hash with one that was published earlier.
- */
 export declare const LOG_GENESIS: string;
 export interface LogEntry {
     seq: number;
-    /** `signed` on approval, `resigned` when a key rotation replaced the signature. */
-    event: 'signed' | 'resigned';
+    event: "signed" | "resigned";
     quest_id: string;
     version_id: string;
     hash: string;
@@ -27,10 +17,9 @@ export type LogCheck = {
 } | {
     ok: false;
     seq: number;
-    reason: 'bad_sequence' | 'bad_link' | 'bad_hash';
+    reason: "bad_sequence" | "bad_link" | "bad_hash";
 };
-export declare function logEntryHash(e: Omit<LogEntry, 'entry_hash'>): Promise<string>;
-/** Walk entries from the start of the log, or on from `from` when continuing an earlier check. */
+export declare function logEntryHash(e: Omit<LogEntry, "entry_hash">): Promise<string>;
 export declare function verifyLogChain(entries: LogEntry[], from?: {
     size: number;
     head: string;

package/package.d.ts

@@ -1,24 +1,11 @@
-/**
- * The `.seek` file: one quest build, what an `.ipa` is on iOS.
- *
- * `seek build` makes it and signs it with the maker's key, because that key
- * never leaves the maker's machine. The maker uploads it with `seek push` or by
- * dropping it on Store Connect. Either way it is unpacked on the maker's side
- * and goes through the same API, which trusts none of it: Store Connect checks
- * the bundle, the signature and every game file as it always does.
- *
- * It is gzipped JSON, so nothing is ever extracted to a path, and a file that
- * inflates without end stops at `PACKAGE_LIMITS.unpackedBytes`.
- */
-import type { GameManifest } from './games.js';
-import type { Signature } from './sign.js';
-import type { QuestBundle } from './types.js';
+import type { GameManifest } from "./games.js";
+import type { Signature } from "./sign.js";
+import type { QuestBundle } from "./types.js";
 export declare const PACKAGE_EXTENSION = ".seek";
 export declare const PACKAGE_LIMITS: {
     readonly fileBytes: number;
     readonly unpackedBytes: number;
 };
-/** One game as `POST /quests/:quest/games` takes it: `files` is path to base64. */
 export interface GameUpload {
     manifest: GameManifest;
     hash: string;
@@ -28,14 +15,11 @@ export interface QuestPackage {
     format: 1;
     bundle: QuestBundle;
     hash: string;
-    /** Null when it was built without a signing key: the Simulator takes it, Store Connect does not. */
     signature: Signature | null;
-    /** By game id, every game `bundle.manifest.games` names. */
     games: Record<string, GameUpload>;
 }
 export declare class PackageError extends Error {
 }
 export declare const packageFileName: (b: QuestBundle) => string;
-export declare function writePackage(p: Omit<QuestPackage, 'format'>): Promise<Uint8Array>;
-/** The contents of a `.seek` file, once it is whole and the bundle is the one its hash names. */
+export declare function writePackage(p: Omit<QuestPackage, "format">): Promise<Uint8Array>;
 export declare function readPackage(bytes: Uint8Array): Promise<QuestPackage>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@seekprotocol/sdk",
-  "version": "0.1.0",
-  "description": "Build quests for Seek: the kits, the builders, the validator and the bundle compiler.",
+  "version": "0.1.1",
+  "description": "Write quests for the Seek app.",
   "author": {
     "name": "Seek Protocol",
     "url": "https://www.seekprotocol.ai/en"
@@ -11,7 +11,6 @@
     "seek",
     "seekprotocol",
     "quests",
-    "location-based",
     "games"
   ],
   "license": "SEE LICENSE IN LICENSE.md",

package/sign.d.ts

@@ -1,38 +1,17 @@
-/**
- * Signatures on a bundle, the way code signing works on iOS.
- *
- * The CLI signs the bundle hash with the maker's key on `seek submit`, so
- * Store Connect knows the upload came from that maker. After approval Seek
- * signs the same hash with its own key, and the app only shows a bundle that
- * carries Seek's signature. Ed25519 through WebCrypto, so the same code runs
- * in Node, in a Worker and in a Deno edge function.
- */
 export interface Signature {
-    /** Who signed: the maker on submit, Seek on approval. */
-    by: 'maker' | 'seek';
-    /** Which key, so keys can be rotated. */
+    by: "maker" | "seek";
     keyId: string;
-    /** Ed25519 over the UTF-8 bytes of `signedMessage(hash, by)`, base64url. */
     sig: string;
 }
-/**
- * What a signature covers: the purpose, the signer's role and the hash. A
- * signature made here can never pass for one on anything else, and a maker's
- * can never pass for Seek's.
- */
 export declare const signedMessage: (hash: string, by: Signature["by"]) => string;
-/** The public keys Seek's signatures are checked against, by `keyId`. A rotated key stays until nothing needs it. */
 export type Keyring = Record<string, JsonWebKey>;
 export interface KeyPairJwk {
     keyId: string;
     publicJwk: JsonWebKey;
     privateJwk: JsonWebKey;
 }
-/** A new signing key. `keyId` is the first 16 hex characters of the public key's SHA-256. */
 export declare function generateSigningKey(): Promise<KeyPairJwk>;
-/** The `keyId` of a key, from its public half: first 16 hex characters of the SHA-256. */
 export declare function keyIdOf(jwk: JsonWebKey): Promise<string>;
-export declare function signHash(hash: string, by: Signature['by'], keyId: string, privateJwk: JsonWebKey): Promise<Signature>;
+export declare function signHash(hash: string, by: Signature["by"], keyId: string, privateJwk: JsonWebKey): Promise<Signature>;
 export declare function verifyHash(hash: string, signature: Signature, publicJwk: JsonWebKey): Promise<boolean>;
-/** True when a key of the ring, named by the signature itself, made this Seek signature. */
 export declare function verifySeekSignature(hash: string, signature: Signature, ring: Keyring): Promise<boolean>;

package/types.d.ts

@@ -1,27 +1,6 @@
-/**
- * What a quest is, as a maker writes it and as Seek runs it.
- *
- * A maker describes a quest with the builders in `./builders`; `compile`
- * turns that description into a `QuestBundle`, which is plain JSON. The
- * bundle is the only thing that leaves the maker's machine, and Seek's
- * server is the only thing that runs it: no maker code is executed on a
- * phone or on Seek's side. What a step can ask for is exactly what this file
- * lists, and every one of those things is a fact the server can check
- * itself (an attested position, a catch, a verified step count, an arena win).
- */
-/** The bundle format. Bumped only for a change an older Seek cannot read. */
 export declare const BUNDLE_FORMAT: 1;
-/**
- * The quest runtime this SDK targets.
- *
- * The app reports which runtime it carries; a bundle that needs a newer one is
- * only offered to players whose app has it, the way an iOS app names its
- * minimum iOS version.
- */
 export declare const SDK_RUNTIME: 1;
-/** A minigame's id inside its quest: its folder `games/<id>/` and `step.play({ game })`. 3 to 30 characters. */
 export declare const GAME_ID_PATTERN: RegExp;
-/** A piece of player-facing text, written in English; Seek translates it. */
 export interface Text {
     en: string;
 }
@@ -29,178 +8,141 @@ export interface Point {
     lat: number;
     lng: number;
 }
-/**
- * Where the quest is played.
- *
- * Seek decides where each marker actually stands inside it (on a street a
- * player can walk to, never in a building or a no-go zone), so an area is a
- * playing field and not an address.
- */
 export type Area = {
-    kind: 'anywhere';
+    kind: "anywhere";
 } | {
-    kind: 'circle';
+    kind: "circle";
     name: string;
     center: Point;
     radiusM: number;
 };
-/** A place a step points at. Seek moves the marker to the nearest safe, walkable spot. */
 export interface Place {
     name: string;
     at: Point;
 }
-/** Everything a bundle may be granted. Each is approved by Seek on its own. */
-export declare const CAPABILITIES: readonly ["location.markers", "spawns.place", "catch", "steps", "arena", "rewards.cards", "rewards.cosmetics", "rewards.boosts", "rewards.crypto", "gamekit"];
+export declare const CAPABILITIES: readonly [
+    "location.markers",
+    "spawns.place",
+    "catch",
+    "steps",
+    "arena",
+    "rewards.cards",
+    "rewards.cosmetics",
+    "rewards.boosts",
+    "rewards.crypto",
+    "gamekit"
+];
 export type Capability = (typeof CAPABILITIES)[number];
 interface StepBase {
-    /** Stable across versions: a player's progress names it. */
     id: string;
-    /** One line in the tracker: what to do now. */
     title: Text;
-    /** The longer telling, shown when the step opens. */
     story?: Text;
-    /** The step that follows. Defaults to the next one in the list; `null` ends the quest. */
     next?: string | null;
 }
-/** Reach the quest-giver and hear them out. */
 export interface TalkStep extends StepBase {
-    kind: 'talk';
-    /** A character from Seek's catalogue, or one the maker had approved. */
+    kind: "talk";
     giver: string;
-    /** Where the giver stands. Defaults to the centre of the area. */
     at?: Place;
 }
-/** Reach a place. */
 export interface ArriveStep extends StepBase {
-    kind: 'arrive';
+    kind: "arrive";
     at: Place;
-    /** How close counts as there, in metres. */
     radiusM: number;
 }
-/** Catch coins. */
 export interface CatchStep extends StepBase {
-    kind: 'catch';
-    /** `memecoins.key`, or `any` for any coin. */
+    kind: "catch";
     coin: string;
     count: number;
-    /** Only catches near this place count, and Seek may put coins there. */
     near?: Place;
     withinM?: number;
 }
-/** Walk. */
 export interface WalkStep extends StepBase {
-    kind: 'walk';
+    kind: "walk";
     steps: number;
-    /** Only steps Seek verified (walked while hunting) count. */
     verified: boolean;
 }
-/** Win arena matches. */
 export interface ArenaStep extends StepBase {
-    kind: 'arena';
+    kind: "arena";
     wins: number;
 }
-/** The player chooses; each option leads to its own step. */
 export interface ChoiceStep extends StepBase {
-    kind: 'choice';
+    kind: "choice";
     options: {
         id: string;
         label: Text;
         next: string | null;
     }[];
 }
-/** Play an HTML5 minigame. The score is advisory; Seek checks it against the reviewed envelope. */
 export interface PlayStep extends StepBase {
-    kind: 'play';
-    /** The minigame's folder in the quest project, `games/<game>/`. */
+    kind: "play";
     game: string;
-    /** The score that completes the step. */
     minScore: number;
-    /** The highest score a real run can reach, fixed at review. */
     maxScore: number;
 }
 export type Step = TalkStep | ArriveStep | CatchStep | WalkStep | ArenaStep | ChoiceStep | PlayStep;
-export type StepKind = Step['kind'];
-/**
- * What finishing the quest is worth.
- *
- * The maker picks from Seek's catalogue; Seek funds it, caps it and pays it.
- * The numbers here are what the bundle asks for, and the server decides what
- * is actually granted.
- */
+export type StepKind = Step["kind"];
 export type Reward = {
-    kind: 'xp';
+    kind: "xp";
     amount: number;
 } | {
-    kind: 'card';
+    kind: "card";
     card: string;
 } | {
-    kind: 'cosmetic';
+    kind: "cosmetic";
     item: string;
 } | {
-    kind: 'boost';
+    kind: "boost";
     boost: string;
     count: number;
 } | {
-    kind: 'pool';
+    kind: "pool";
     coin: string;
     perPlayer: number;
     maxPlayers: number;
 };
-/**
- * What the maker declares about the quest, as stores ask for a content rating
- * and a privacy label. Seek shows it to players and reviewers, checks what it
- * can against the steps, and a wrong declaration is a reason to reject.
- */
 export interface Declarations {
-    /** Where players are sent: public places only, or also private ground the maker has permission for. */
-    places: 'public' | 'private_with_permission';
-    /** How hard it is on the body, all steps together. */
-    effort: 'light' | 'moderate' | 'hard';
-    /** Whether a step takes players near traffic, water, heights or other dangers they must watch for. */
+    places: "public" | "private_with_permission";
+    effort: "light" | "moderate" | "hard";
     hazards: boolean;
-    /** Whether AI wrote texts or made art or code in the quest. */
-    ai: 'none' | 'assisted' | 'generated';
-    /** Whether a brand paid for the quest or appears in it. Players are told. */
+    ai: "none" | "assisted" | "generated";
     sponsored: boolean;
-    /** Whether the quest's minigames record gameplay events (GameKit `track`). */
     gameEvents: boolean;
-    /**
-     * Required, and always true: every text, image, sound, font, character,
-     * logo and line of code in the quest and its games is yours, or you have a
-     * licence for this use. A build that says otherwise is not accepted.
-     */
     rights: true;
 }
 export declare const DECLARATION_VALUES: {
-    readonly places: readonly ["public", "private_with_permission"];
-    readonly effort: readonly ["light", "moderate", "hard"];
-    readonly ai: readonly ["none", "assisted", "generated"];
+    readonly places: readonly [
+        "public",
+        "private_with_permission"
+    ];
+    readonly effort: readonly [
+        "light",
+        "moderate",
+        "hard"
+    ];
+    readonly ai: readonly [
+        "none",
+        "assisted",
+        "generated"
+    ];
 };
 export interface QuestDefinition {
-    /** Unique per maker, lowercase: `[a-z0-9-]`, 3 to 40 long. */
     id: string;
     title: Text;
     summary?: Text;
     area: Area;
-    /** When the quest can be started and finished, ISO 8601. */
     window?: {
         from: string;
         to: string;
     };
-    /** Whether a finished quest can be played again. */
-    repeat?: 'never' | 'daily' | 'weekly';
+    repeat?: "never" | "daily" | "weekly";
     capabilities: Capability[];
     steps: Step[];
     rewards: Reward[];
-    /** The youngest player who may see it. Anything that pays is 18. */
     minAge?: 13 | 16 | 18;
-    /** Required: what the quest asks of players and what it contains. */
     declarations: Declarations;
 }
-/** The text table of a bundle: key to English. Seek fills in the other 30 languages. */
 export type TextTable = Record<string, string>;
-/** A step as it is stored in a bundle: texts replaced by keys, `next` resolved. */
-type CompileOne<S extends Step> = Omit<S, 'title' | 'story' | 'next' | 'options'> & {
+type CompileOne<S extends Step> = Omit<S, "title" | "story" | "next" | "options"> & {
     title: string;
     story?: string;
     next: string | null;
@@ -218,12 +160,9 @@ export type CompiledStep = {
 }[StepKind];
 export interface QuestManifest {
     format: typeof BUNDLE_FORMAT;
-    /** The SDK runtime the app must carry to show this bundle. */
     runtime: number;
     id: string;
-    /** Semantic version, raised by the maker for every submission. */
     version: string;
-    /** Strictly increasing per quest, like an iOS build number. */
     build: number;
     title: string;
     summary?: string;
@@ -232,17 +171,14 @@ export interface QuestManifest {
         from: string;
         to: string;
     };
-    repeat: 'never' | 'daily' | 'weekly';
+    repeat: "never" | "daily" | "weekly";
     minAge: 13 | 16 | 18;
     declarations: Declarations;
     capabilities: Capability[];
     rewards: Reward[];
-    /** The step a new player starts on. */
     start: string;
-    /** GameKit: each `play` step's game, by id, to its game hash. Absent when the quest has no games. */
     games?: Record<string, string>;
 }
-/** What `seek build` writes and `seek submit` uploads. Plain JSON. */
 export interface QuestBundle {
     manifest: QuestManifest;
     steps: CompiledStep[];

package/validate.d.ts

@@ -1,14 +1,4 @@
-/**
- * Whether a quest is one Seek can run.
- *
- * The same checks run in three places: `seek test` on the maker's machine,
- * `seek submit` before the upload, and Store Connect's review pipeline on what
- * arrived. A maker sees the answer the reviewer will see, before submitting.
- *
- * The limits are Seek's, not the maker's: they keep a quest walkable, finite
- * and inside what the reward pipeline is built to pay.
- */
-import { type Capability, type Point, type QuestDefinition, type Step } from './types.js';
+import { type Capability, type Point, type QuestDefinition, type Step } from "./types.js";
 export declare const LIMITS: {
     readonly steps: {
         readonly min: 1;
@@ -61,15 +51,11 @@ export declare const LIMITS: {
     };
 };
 export interface Issue {
-    /** Where, as a path into the definition: `steps[2].radiusM`. */
     path: string;
     code: string;
     message: string;
 }
-/** Metres between two points, on a sphere. Good to well under a metre at these distances. */
 export declare function distanceM(a: Point, b: Point): number;
-/** The capabilities a definition actually uses, whether or not it declares them. */
 export declare function usedCapabilities(q: QuestDefinition): Set<Capability>;
-/** Where each step leads: its own `next`, its options, or the one after it. */
 export declare function successors(steps: readonly Step[], index: number): (string | null)[];
 export declare function validate(q: QuestDefinition): Issue[];

package/verify.d.ts

@@ -1,5 +1,5 @@
-import type { QuestBundle, QuestDefinition } from './types.js';
-import type { Issue } from './validate.js';
+import type { QuestBundle, QuestDefinition } from "./types.js";
+import type { Issue } from "./validate.js";
 export declare function decompile(bundle: QuestBundle): QuestDefinition;
 export type BundleCheck = {
     ok: true;