cajonzero 0.1.0 → 0.1.2

package/dist/{providers-CJgLgWh4.d.ts → providers-BX7e4pNW.d.ts}

@@ -199,7 +199,7 @@ declare function createMemoryStore(): Store;
  * cajonzero — typed repositories over the unstorage layer (T4).
  *
  * Thin, dependency-injected repositories for the embedded account system
- * (`accounts`, `sessions`, `bans`, `ratelimits`), runtime settings, and the
+ * (`accounts`, `sessions`, `bans`), runtime settings, and the
  * map-script storage-kv API (`mapStorage`). Each is a small closure over a
  * {@link Store}; no repository knows about HTTP, Hono, or Cloudflare globals, so
  * every one is exercisable on the in-memory driver.
@@ -332,21 +332,6 @@ interface BansRepo {
     deleteByKey(key: string): Promise<boolean>;
     isActive(ban: BanRecord, at?: number): boolean;
 }
-/** Fixed-window rate-limit state. */
-interface RateLimitState {
-    count: number;
-    windowStart: number;
-    expiresAt: number;
-}
-interface RateLimitIncrementOptions {
-    readonly windowSeconds?: number;
-    readonly amount?: number;
-}
-interface RateLimitsRepo {
-    increment(scope: string, hash: string, options?: RateLimitIncrementOptions): Promise<RateLimitState>;
-    get(scope: string, hash: string): Promise<RateLimitState | undefined>;
-    reset(scope: string, hash: string): Promise<void>;
-}
 interface SettingsRepo {
     get<T = JSONValue>(key: string): Promise<T | undefined>;
     set(key: string, value: JSONValue): Promise<void>;
@@ -384,7 +369,6 @@ interface Repos {
     readonly accounts: AccountsRepo;
     readonly sessions: SessionsRepo;
     readonly bans: BansRepo;
-    readonly ratelimits: RateLimitsRepo;
     readonly settings: SettingsRepo;
     /** Builds a map-script storage repo for one `(scope, namespace)`. */
     mapStorage(scope: string, namespace: string): MapStorageRepo;
@@ -551,11 +535,6 @@ interface MapEntry {
     readonly version?: string;
     /** Cover image URL for the lobby. */
     readonly cover?: string;
-    /**
-     * Cache revision (content hash, release tag, …). Seeds are cached in KV only
-     * when a revision is present, so bump it whenever the uploaded map changes.
-     */
-    readonly etag?: string;
     /** Optional CDN root for browser assets; defaults to {@link root}. */
     readonly assetRoot?: string;
 }
@@ -924,6 +903,35 @@ declare class MuStruct<Spec extends {
     constructor(spec: Spec);
 }
 
+interface Dictionary<Schema extends MuSchema<any>> {
+    [key: string]: Schema['identity'];
+}
+declare class MuDictionary<ValueSchema extends MuSchema<any>> implements MuSchema<Dictionary<ValueSchema>> {
+    readonly muType = "dictionary";
+    readonly identity: Dictionary<ValueSchema>;
+    readonly muData: ValueSchema;
+    readonly json: object;
+    readonly capacity: number;
+    private _isPrimitive;
+    allocCount: number;
+    freeCount: number;
+    stats(): {
+        allocCount: number;
+        freeCount: number;
+        poolSize: number;
+    };
+    constructor(schema: ValueSchema, capacity: number, identity?: Dictionary<ValueSchema>);
+    alloc(): Dictionary<ValueSchema>;
+    free(dict: Dictionary<ValueSchema>): void;
+    equal(a: Dictionary<ValueSchema>, b: Dictionary<ValueSchema>): boolean;
+    clone(dict: Dictionary<ValueSchema>): Dictionary<ValueSchema>;
+    assign: (dst: Dictionary<ValueSchema>, src: Dictionary<ValueSchema>) => Dictionary<ValueSchema>;
+    diff(base: Dictionary<ValueSchema>, target: Dictionary<ValueSchema>, out: MuWriteStream): boolean;
+    patch(base: Dictionary<ValueSchema>, inp: MuReadStream): Dictionary<ValueSchema>;
+    toJSON(dict: Dictionary<ValueSchema>): Dictionary<any>;
+    fromJSON(x: Dictionary<any>): Dictionary<ValueSchema>;
+}
+
 declare class QuantizedScalar implements MuSchema<number> {
     precision: number;
     invPrecision: number;
@@ -2265,6 +2273,48 @@ declare const NetPublicSchema: MuStruct<{
 }>;
 type NetPublic = typeof NetPublicSchema.identity;
 
+declare class RelativeArray<TSchema extends MuSchema<any>> implements MuSchema<TSchema['identity'][]> {
+    identity: TSchema['identity'][];
+    muType: string;
+    muData: TSchema;
+    json: any;
+    arraySchema: MuArray<TSchema>;
+    alloc: () => TSchema['identity'][];
+    free: (x: TSchema['identity'][]) => void;
+    clone: (x: TSchema['identity'][]) => TSchema['identity'][];
+    equal: (x: TSchema['identity'][], y: TSchema['identity'][]) => boolean;
+    assign: (x: TSchema['identity'][], y: TSchema['identity'][]) => TSchema['identity'][];
+    toJSON: (x: TSchema['identity'][]) => any[];
+    fromJSON: (x: any) => TSchema['identity'][];
+    constructor(schema: TSchema, capacity: number, identity?: TSchema['identity'][]);
+    diff(base: TSchema['identity'][], target: TSchema['identity'][], stream: MuWriteStream): boolean;
+    patch(base: TSchema['identity'][], stream: MuReadStream): TSchema['identity'][];
+}
+
+declare const BlockInfoSchema: MuStruct<{
+    ids: RelativeArray<MuRelativeVarint>;
+    names: MuArray<MuUTF8>;
+    emissive: RelativeArray<MuVarint>;
+    texture: RelativeArray<MuRelativeVarint>;
+    animLength: RelativeArray<MuVarint>;
+    friction: RelativeArray<MuQuantizedFloat>;
+    restitution: RelativeArray<MuQuantizedFloat>;
+    velocity: RelativeArray<MuFloat32>;
+    fluids: MuArray<MuStruct<{
+        id: MuVarint;
+        info: MuUint32;
+        mass: MuFloat64;
+    }>>;
+    category: MuDictionary<RelativeArray<MuRelativeVarint>>;
+    atlasRadius: MuVarint;
+    blockBumpShift: MuVarint;
+    blockColorShift: MuVarint;
+    colorAtlas: MuArray<MuASCII>;
+    materialAtlas: MuArray<MuASCII>;
+    bumpAtlas: MuArray<MuASCII>;
+}>;
+type BlockInfo = typeof BlockInfoSchema.identity;
+
 /**
  * cajonzero — map-driven world seed (T26 slice 2, priority 1).
  *
@@ -2406,6 +2456,15 @@ interface WorldSeed {
     entityCount: number;
     /** Human-readable record of anything skipped (never silently dropped). */
     warnings: string[];
+    /**
+     * Decoded block palette, when the loader managed to read it.
+     *
+     * Server-only and **not JSON-safe** (typed arrays + schema refs): the seed is
+     * never serialized any more, but do not persist this field. The engine uses
+     * it to build the real `BlockIndex` (conveyors/materials) instead of the
+     * neutral palette.
+     */
+    blockInfo?: BlockInfo;
 }
 /**
  * Read one archive-relative file. Implementations: an in-memory map (tests /
@@ -3759,6 +3818,12 @@ interface SnapshotClient {
     admin: boolean;
     loginState: number;
 }
+/** Identity of the map a snapshot's world belongs to. */
+interface SnapshotMap {
+    slug: string;
+    root: string;
+    worldId?: string;
+}
 /** The durable room state written to Durable Object storage. */
 interface RoomSnapshot {
     version: number;
@@ -3768,6 +3833,12 @@ interface RoomSnapshot {
     /** Opaque, JSON-safe world state produced by `RoomEngine.capture()`. */
     engine: unknown;
     clients: SnapshotClient[];
+    /**
+     * Map the captured world came from. Absent for snapshots written before the
+     * field existed (or by a room that never had a map); those must not be
+     * restored over a freshly seeded world.
+     */
+    map?: SnapshotMap;
 }
 
 declare enum HashType {
@@ -4876,7 +4947,6 @@ interface RoomStateLike {
  * the effective fetch policy from `cajonzero/config.json`.
  */
 interface RoomMapBootstrap extends MapEntry {
-    readonly cacheTtlSeconds?: number;
     readonly maxDownloadBytes?: number;
     readonly concurrency?: number;
     readonly requestTimeoutMs?: number;
@@ -4966,7 +5036,6 @@ declare class Room {
     private script;
     private readonly explicitScriptHost;
     private readonly mapLoader;
-    private readonly seedCacheKv;
     private readonly sockets;
     /** mudb wire codec: protocol envelope + netcode frames. */
     private readonly codec;
@@ -5008,6 +5077,8 @@ declare class Room {
     private mapLoading;
     private worldReady;
     private snapshotRestored;
+    /** One-shot guard for the "proof without sessionSecret" diagnostic. */
+    private guestWarningLogged;
     private persistence;
     private socketsStarted;
     private perf;
@@ -5019,6 +5090,10 @@ declare class Room {
     private readonly inboundIds;
     /** Snapshot parked by `init()` until the seeded engine exists. */
     private pendingEngineSnapshot;
+    /** Map identity stored with the parked snapshot (absent on legacy snapshots). */
+    private pendingEngineMap;
+    /** Identity of the map the current engine was seeded from. */
+    private seededMap;
     private heartbeatBeats;
     private ticksRun;
     private lastTickError;
@@ -5055,7 +5130,15 @@ declare class Room {
      * any connection is admitted.
      */
     private ensureWorld;
-    /** Apply a snapshot parked by `init()` exactly once (seeded or not). */
+    /**
+     * Apply a snapshot parked by `init()` exactly once.
+     *
+     * A snapshot describes the world of the map it was captured from. Restoring
+     * one that came from another map (or from a room that never had a map) would
+     * replace the freshly seeded entities with nothing, leaving terrain but no
+     * models — so it is dropped instead. Dropping it also resets the tick
+     * counters, which `init()` had adopted optimistically.
+     */
     private applyPendingEngineSnapshot;
     private loadWorld;
     private loadSeed;
@@ -5263,8 +5346,6 @@ interface RuntimeProviders {
     readonly adminToken?: EnvProvider<string>;
     /** Deployment label; `"development"` relaxes cookie `Secure`. */
     readonly environment?: EnvProvider<string>;
-    /** KV used for the resolved map-seed cache. */
-    readonly mapSeedKv?: EnvProvider<KVNamespace>;
     /** Durable Object namespace that hosts rooms. */
     readonly rooms?: EnvProvider<DurableObjectNamespace>;
     /** Defaults for settings that have never been persisted. */
@@ -5277,9 +5358,8 @@ declare function getRuntimeProviders(): RuntimeProviders;
 declare function resolveSessionSecret(env: Env): string | undefined;
 declare function resolveAdminToken(env: Env): string | undefined;
 declare function resolveEnvironment(env: Env): string | undefined;
-declare function resolveMapSeedKv(env: Env): KVNamespace | undefined;
 declare function resolveRooms(env: Env): DurableObjectNamespace | undefined;
 declare function resolveSettingDefaults(env: Env): SettingDefaults | undefined;
 
-export { parseMapCatalog as A, resolveAdminToken as B, resolveEnvironment as C, resolveMapSeedKv as F, resolveRooms as G, resolveSessionSecret as H, resolveSettingDefaults as I, resolveStore as J, setRuntimeProviders as L, setStorageFactory as N, Room as R, EMPTY_MAP_CATALOG as c, SETTINGS as h, SETTING_KEYS as i, SettingsError as l, configureDefaultKV as r, createMemoryStore as s, createRepos as t, createSettingsService as u, createStore as v, findMap as w, getRuntimeProviders as x, isSettingKey as y, memoryDriver as z };
-export type { DurableObjectNamespace as D, EnvProvider as E, KVNamespace as K, MapEntry as M, SessionsRepo as O, NetPublic as P, NetSecret as Q, StorageSource as S, TimestampedClientInput as T, WorldSeed as W, SettingDefaults as a, Env as b, MapCatalog as d, Repos as e, RoomOptions as f, RuntimeProviders as g, SettingDefinition as j, Settings as k, SettingsErrorCode as m, SettingsService as n, StorageFactory as o, Store as p, WorldSeedReader as q };
+export { parseMapCatalog as A, resolveAdminToken as B, resolveEnvironment as C, resolveRooms as F, resolveSessionSecret as G, resolveSettingDefaults as H, resolveStore as I, setRuntimeProviders as J, setStorageFactory as K, Room as R, EMPTY_MAP_CATALOG as c, SETTINGS as h, SETTING_KEYS as i, SettingsError as l, configureDefaultKV as r, createMemoryStore as s, createRepos as t, createSettingsService as u, createStore as v, findMap as w, getRuntimeProviders as x, isSettingKey as y, memoryDriver as z };
+export type { DurableObjectNamespace as D, EnvProvider as E, SessionsRepo as L, MapEntry as M, NetPublic as N, NetSecret as O, StorageSource as S, TimestampedClientInput as T, WorldSeed as W, SettingDefaults as a, Env as b, MapCatalog as d, Repos as e, RoomOptions as f, RuntimeProviders as g, SettingDefinition as j, Settings as k, SettingsErrorCode as m, SettingsService as n, StorageFactory as o, Store as p, WorldSeedReader as q };

package/dist/scaffold.d.ts

@@ -146,5 +146,63 @@ declare function toPackageName(folder: string): string;
  */
 declare function createProject(folder: string, options?: CreateProjectOptions): ScaffoldResult;
 
-export { SCAFFOLD_COMPATIBILITY_DATE, SCAFFOLD_CONFIG_CONTENT, SCAFFOLD_ENTRY_CONTENT, SCAFFOLD_ENTRY_PATH, SCAFFOLD_KV_PLACEHOLDER_ID, SCAFFOLD_MAPS_CONTENT, ScaffoldError, buildScaffoldFiles, createProject, readCajonzeroPackage, toPackageName };
-export type { CajonzeroPackageInfo, CreateProjectOptions, ScaffoldErrorCode, ScaffoldFile, ScaffoldResult, ScaffoldTemplateOptions };
+/** Where one setup value is written. */
+type SetupKind = "var" | "secret";
+/** One configurable value. */
+interface SetupField {
+    readonly name: string;
+    /** Chinese prompt label. */
+    readonly label: string;
+    readonly kind: SetupKind;
+    /** `true` for the values a project cannot run without. */
+    readonly required: boolean;
+    /** Default shown in the prompt (secrets: generated when absent). */
+    readonly default?: string;
+    /** Short explanation printed next to the prompt. */
+    readonly hint?: string;
+}
+/** Every value `setup` manages. */
+declare const SETUP_FIELDS: readonly SetupField[];
+/** Files `setup` touched. */
+interface SetupResult {
+    readonly configPath: string;
+    readonly devVarsPath: string;
+    /** Non-secret values written to `wrangler.jsonc`. */
+    readonly vars: Record<string, string>;
+    /** Secrets written to `.dev.vars`. */
+    readonly secrets: Record<string, string>;
+}
+interface SetupOptions {
+    readonly cwd?: string;
+    /** Wrangler config path (default `wrangler.jsonc`). */
+    readonly configPath?: string;
+    /** Values to write; managed keys absent here are removed. */
+    readonly values: Readonly<Record<string, string>>;
+}
+/** Generated default for a required secret. */
+declare function generateSecret(): string;
+/** Generated default for the owner token (shorter, URL-safe). */
+declare function generateAdminToken(): string;
+/** Default value for a field when it has no configured value yet. */
+declare function suggestedValue(field: SetupField): string | undefined;
+/** Parse `.dev.vars` (`KEY=value`, `#` comments). */
+declare function parseDevVars(text: string): Record<string, string>;
+/** Serialize `.dev.vars` (stable order, trailing newline). */
+declare function serializeDevVars(values: Record<string, string>): string;
+/**
+ * Merge `vars` into the `wrangler.jsonc` `"vars"` object.
+ *
+ * Keys not managed by cajonzero are preserved; managed keys absent from `vars`
+ * are removed so clearing a setting falls back to its default.
+ */
+declare function setWranglerVars(raw: string, vars: Readonly<Record<string, string>>): string;
+/** Read currently configured values (wrangler vars + `.dev.vars`). */
+declare function readSetupValues(cwd: string, configPath: string, devVarsPath: string): Record<string, string>;
+/**
+ * Apply the answers: non-secret values to `wrangler.jsonc`, secrets to
+ * `.dev.vars`. Throws when the project files are missing.
+ */
+declare function applySetup(options: SetupOptions): SetupResult;
+
+export { SCAFFOLD_COMPATIBILITY_DATE, SCAFFOLD_CONFIG_CONTENT, SCAFFOLD_ENTRY_CONTENT, SCAFFOLD_ENTRY_PATH, SCAFFOLD_KV_PLACEHOLDER_ID, SCAFFOLD_MAPS_CONTENT, SETUP_FIELDS, ScaffoldError, applySetup, buildScaffoldFiles, createProject, generateAdminToken, generateSecret, parseDevVars, readCajonzeroPackage, readSetupValues, serializeDevVars, setWranglerVars, suggestedValue, toPackageName };
+export type { CajonzeroPackageInfo, CreateProjectOptions, ScaffoldErrorCode, ScaffoldFile, ScaffoldResult, ScaffoldTemplateOptions, SetupField, SetupKind, SetupOptions, SetupResult };