@zakkster/lite-camera-pro 1.0.1 → 1.1.0

package/CHANGELOG.md

@@ -6,6 +6,53 @@ Versioning. Version lives in three places at once -- `package.json`, the
 `VERSION` const in `src/index.js`, and the `Version:` header in `llms.txt` --
 bumped together or not at all.
 
+## [1.1.0] -- 2026-08-26
+
+Subpath exports. A consumer who needs only screen shake now imports
+`@zakkster/lite-camera-pro/shake` and pays for the shake engine plus its
+tree-shaken noise sampler -- nothing else. No runtime behavior changed: the hot
+bodies (`computeShake`, `updateShake`, `apply`, `updateParallax`, `applyBounds`,
+`updateMultiTarget`) are byte-identical, and the camera class imports the same
+module files the subpaths expose (one engine, no fork -- proven by the T8
+Object.is identity check).
+
+Measured: the Las Vegas scratch-card consumer (BRIEF.md) reported a 73.5 KB gz
+whole-package pull for a three-tier win-shake ramp that touches only the shake
+API. Through `@zakkster/lite-camera-pro/shake` the same integration measures
+**2.82 KB gz** (2,883 B; 8.79 KB raw, esbuild esm, minify=false, gzip -9) --
+about **26x smaller**. Of that bundle, lite-noise's `Noise.js` contributes
+2,009 B (5.1% of its 39,613 B source), so tree-shaking through the noise
+dependency works as intended.
+
+### Added
+
+- **Subpath exports map.** Seven entries beside `.`: `./shake`, `./parallax`,
+  `./bounds`, `./multi`, `./follow`, `./sequence`, and `./package.json`. Each
+  runtime entry carries a sibling `types` condition (declared first, per the
+  TypeScript exports-map requirement). Per-subpath gz weights (esm, unminified,
+  gzip -9): `./shake` 2.82 KB, `./parallax` 0.89 KB, `./bounds` 1.13 KB,
+  `./multi` 0.89 KB, `./follow` 0.71 KB, `./sequence` 5.94 KB, `.` 21.70 KB.
+  `./sequence` drags `@zakkster/lite-timeline` + `@zakkster/lite-ease` by design
+  -- it is the only subpath that does.
+- **`src/Shake.js` barrel.** A two-line re-export over `ShakeEngine.js` +
+  `ShakePresets.js` (never a copy), so a shake-only consumer gets the engine,
+  the presets, and `getPreset`/`registerPreset`/`listPresets` from one import.
+- **Typed functional layer (CP-16a).** `src/index.d.ts` now re-exports six
+  per-subsystem sibling declarations (`Shake.d.ts`, `ParallaxManager.d.ts`,
+  `BoundsSystem.d.ts`, `MultiTarget.d.ts`, `FollowMode.d.ts`,
+  `CameraSequence.d.ts`), each declaring its module's complete runtime surface
+  -- state interfaces, enums, defaults, no `any`. The standalone functions are
+  now visible and typed at the main entry, not just the class.
+- **Size gate.** `test/size.mjs` bundles every subpath with the esbuild JS API
+  and asserts `./shake` gz stays at or under the fixed 16,384 B charter budget.
+  Wired into `npm run verify`.
+- **Dependency decision record (CP-17).** `decisions/0001-layout-and-deps.md`
+  documents the multi-file layout and the five first-party runtime deps, with
+  per-dep floor evidence. Repo-only; not shipped in the tarball.
+- **TypeScript smoke.** `test/types-smoke/smoke.ts` exercises every subpath plus
+  the main entry under `strict` + `noImplicitAny` + node16 resolution;
+  `npm run typecheck` runs it and joins `prepublishOnly`.
+
 ## [1.0.1] -- 2026-08-25
 
 Foundation release: make the suite run, gate it, and land the fixes that cost

package/README.md

@@ -20,6 +20,13 @@
 npm install @zakkster/lite-camera-pro
 ```
 
+Need only screen shake? Import the `./shake` subpath and pull just the engine +
+presets (2.82 KB gz -- esm, unminified, gzip -9):
+
+```js
+import { createShakeState, addShake, updateShake, computeShake, getPreset } from '@zakkster/lite-camera-pro/shake';
+```
+
 ---
 
 ## Why Pro?

package/llms.txt

@@ -6,7 +6,7 @@
 > with presets, fluent timeline sequences, a 16-layer parallax manager, per-edge
 > bounds, a debug HUD, and zero-alloc coordinate conversion.
 
-Version: 1.0.1
+Version: 1.1.0
 
 ESM only. `import` from `@zakkster/lite-camera-pro`. Default export is the
 CinematicCameraPro class. All hot-path APIs avoid allocation; setup-time calls
@@ -109,6 +109,19 @@ Multi:    createMultiTargetState, updateMultiTarget
 Sequence: createCameraSequence, panTo, dramaticZoom, bossReveal, timedShake
 Enums:    FollowMode, FOLLOW_STRATEGIES, BoundsType, WrapMode
 
+## Subpath exports (import only what you use; gz, esm, unminified, gzip -9)
+Beside the "." main entry, six subsystem subpaths + "./package.json". Same runtime
+identities as the main entry (one engine, no fork). Per-subpath gz weight:
+  ./shake     2.82 KB  createShakeState, addShake, addTraumaSimple, updateShake, computeShake, clearShakes + presets/getPreset/registerPreset/listPresets
+  ./parallax  0.89 KB  createParallaxState, addParallaxLayer, removeParallaxLayer, updateParallax, getLayerScroll, applyParallaxLayer, WrapMode
+  ./bounds    1.13 KB  createBoundsState, setBoundsAll, setBoundsEdges, setBoundsRect, clearBoundsRect, applyBounds, BoundsType
+  ./multi     0.89 KB  createMultiTargetState, updateMultiTarget
+  ./follow    0.71 KB  FollowMode, FOLLOW_STRATEGIES
+  ./sequence  5.94 KB  createCameraSequence, panTo, dramaticZoom, bossReveal, timedShake  (drags lite-timeline + lite-ease by design -- the only subpath that does)
+  .           21.70 KB full class + functional layer
+Self-reference example (shake only):
+  import { createShakeState, addShake, updateShake, computeShake, getPreset } from '@zakkster/lite-camera-pro/shake';
+
 ## Dependencies (all @zakkster, first-party)
 @zakkster/lite-camera (base CinematicCamera), lite-ease, lite-lerp, lite-noise, lite-timeline.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zakkster/lite-camera-pro",
   "author": "Zahary Shinikchiev <shinikchiev@yahoo.com>",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Cinematic camera system for Canvas2D games. Zero-GC, multi-target framing, noise-based shake, and timeline sequences.",
   "type": "module",
   "sideEffects": false,
@@ -13,7 +13,44 @@
       "node": "./src/index.js",
       "import": "./src/index.js",
       "default": "./src/index.js"
-    }
+    },
+    "./shake": {
+      "types": "./src/Shake.d.ts",
+      "node": "./src/Shake.js",
+      "import": "./src/Shake.js",
+      "default": "./src/Shake.js"
+    },
+    "./parallax": {
+      "types": "./src/ParallaxManager.d.ts",
+      "node": "./src/ParallaxManager.js",
+      "import": "./src/ParallaxManager.js",
+      "default": "./src/ParallaxManager.js"
+    },
+    "./bounds": {
+      "types": "./src/BoundsSystem.d.ts",
+      "node": "./src/BoundsSystem.js",
+      "import": "./src/BoundsSystem.js",
+      "default": "./src/BoundsSystem.js"
+    },
+    "./multi": {
+      "types": "./src/MultiTarget.d.ts",
+      "node": "./src/MultiTarget.js",
+      "import": "./src/MultiTarget.js",
+      "default": "./src/MultiTarget.js"
+    },
+    "./follow": {
+      "types": "./src/FollowMode.d.ts",
+      "node": "./src/FollowMode.js",
+      "import": "./src/FollowMode.js",
+      "default": "./src/FollowMode.js"
+    },
+    "./sequence": {
+      "types": "./src/CameraSequence.d.ts",
+      "node": "./src/CameraSequence.js",
+      "import": "./src/CameraSequence.js",
+      "default": "./src/CameraSequence.js"
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "src/",
@@ -50,15 +87,17 @@
     "@zakkster/lite-gc-profiler": "^1.16.0",
     "@zakkster/lite-leak": "^1.10.0",
     "@zakkster/lite-signal": "^1.5.0",
-    "esbuild": "^0.25.0"
+    "esbuild": "^0.25.0",
+    "typescript": "7.0.2"
   },
   "scripts": {
     "test": "node --test test/*.test.js",
     "test:gc": "node --expose-gc --test test/*.test.js",
     "torture": "node --expose-gc test/torture.mjs",
-    "verify": "npm run test:gc && npm run torture",
+    "verify": "npm run test:gc && npm run torture && node test/size.mjs",
+    "typecheck": "tsc -p test/types-smoke/tsconfig.json",
     "bundle-check": "esbuild ./src/index.js --bundle --format=esm --outfile=test-bundle.js",
-    "prepublishOnly": "npm run verify && npm run bundle-check"
+    "prepublishOnly": "npm run verify && npm run typecheck && npm run bundle-check"
   },
   "keywords": [
     "camera",

package/src/BoundsSystem.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @zakkster/lite-camera-pro/bounds -- TypeScript declarations.
+ *
+ * Configurable per-edge boundary behavior. Pure math, no dependencies.
+ * Complete runtime surface, no `any`.
+ */
+
+// -- Boundary types --
+export declare const BoundsType: {
+    readonly HARD: 0;
+    readonly SOFT: 1;
+    readonly ELASTIC: 2;
+    readonly NONE: 3;
+};
+
+// -- Bounds system state (one per camera) --
+export interface BoundsState {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    softZone: number;
+    elasticMax: number;
+    elasticStrength: number;
+    boundsX: number;
+    boundsY: number;
+    boundsW: number;
+    boundsH: number;
+    customBounds: boolean;
+}
+
+// -- Per-edge config for setBoundsEdges --
+export interface BoundsEdgesConfig {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}
+
+export declare function createBoundsState(): BoundsState;
+export declare function setBoundsAll(state: BoundsState, type: number): void;
+export declare function setBoundsEdges(state: BoundsState, config: BoundsEdgesConfig): void;
+export declare function setBoundsRect(state: BoundsState, x: number, y: number, w: number, h: number): void;
+export declare function clearBoundsRect(state: BoundsState): void;
+export declare function applyBounds(
+    state: BoundsState,
+    target: Float32Array,
+    pos: Float32Array,
+    maxX: number,
+    maxY: number,
+    visW: number,
+    visH: number,
+    dt: number,
+): void;

package/src/CameraSequence.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @zakkster/lite-camera-pro/sequence -- TypeScript declarations.
+ *
+ * Timeline-driven camera choreography. NOTE: this subpath drags
+ * @zakkster/lite-timeline and @zakkster/lite-ease by design -- it is the only
+ * subpath that does. Complete runtime surface, no `any`.
+ */
+
+import type { CinematicCameraPro } from './index.js';
+import type { ShakeProfile } from './Shake.js';
+
+// -- Sequence construction options --
+export interface CameraSequenceOptions {
+    loop?: boolean;
+    onComplete?: () => void;
+    blendOutTime?: number;
+}
+
+// -- Per-step options --
+export interface StepOptions {
+    ease?: (t: number) => number;
+    at?: string | number;
+}
+
+// -- A fluent camera sequence handle --
+export interface CameraSequence {
+    moveTo(x: number, y: number, duration: number, opts?: StepOptions): CameraSequence;
+    zoomTo(level: number, duration: number, opts?: StepOptions): CameraSequence;
+    moveAndZoom(x: number, y: number, level: number, duration: number, opts?: StepOptions): CameraSequence;
+    shake(profileOrName: string | ShakeProfile, intensity?: number, opts?: StepOptions): CameraSequence;
+    wait(duration: number, opts?: StepOptions): CameraSequence;
+    call(fn: () => void, opts?: StepOptions): CameraSequence;
+    play(): CameraSequence;
+    pause(): CameraSequence;
+    resume(): CameraSequence;
+    stop(): CameraSequence;
+    seek(timeMs: number): CameraSequence;
+    destroy(): void;
+    readonly duration: number;
+    readonly progress: number;
+    readonly playing: boolean;
+}
+
+export declare function createCameraSequence(cam: CinematicCameraPro, options?: CameraSequenceOptions): CameraSequence;
+export declare function panTo(
+    cam: CinematicCameraPro,
+    x: number,
+    y: number,
+    duration: number,
+    opts?: CameraSequenceOptions & StepOptions,
+): CameraSequence;
+export declare function dramaticZoom(
+    cam: CinematicCameraPro,
+    x: number,
+    y: number,
+    zoom: number,
+    duration: number,
+    opts?: CameraSequenceOptions & StepOptions,
+): CameraSequence;
+export declare function bossReveal(
+    cam: CinematicCameraPro,
+    x: number,
+    y: number,
+    totalMs?: number,
+    opts?: CameraSequenceOptions,
+): CameraSequence;
+export declare function timedShake(
+    cam: CinematicCameraPro,
+    presetOrProfile: string | ShakeProfile,
+    holdMs?: number,
+    opts?: CameraSequenceOptions,
+): CameraSequence;
+
+declare const _default: typeof createCameraSequence;
+export default _default;

package/src/FollowMode.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @zakkster/lite-camera-pro/follow -- TypeScript declarations.
+ *
+ * Follow-mode enum and the strategy dispatch table. Complete runtime surface,
+ * no `any`.
+ */
+
+import type { CinematicCameraPro } from './index.js';
+
+// -- Follow modes --
+export declare const FollowMode: {
+    readonly SMOOTH: 0;
+    readonly LOCK: 1;
+    readonly PREDICTIVE: 2;
+    readonly CUT: 3;
+    readonly HYBRID: 4;
+};
+
+// -- Strategy dispatch table, indexed by FollowMode value --
+export declare const FOLLOW_STRATEGIES: ReadonlyArray<
+    (cam: CinematicCameraPro, dt: number, px: number, py: number, pvx: number, pvy: number) => void
+>;
+
+declare const _default: typeof FollowMode;
+export default _default;

package/src/MultiTarget.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @zakkster/lite-camera-pro/multi -- TypeScript declarations.
+ *
+ * Multi-target framing: fit several targets in view. Pure math, no
+ * dependencies. Complete runtime surface, no `any`.
+ */
+
+import type { CinematicCameraPro } from './index.js';
+
+// -- A 2D point (target position) --
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+
+// -- Multi-target config/state (one per camera) --
+export interface MultiTargetState {
+    active: boolean;
+    targets: Vec2[] | null;
+    count: number;
+    paddingX: number;
+    paddingY: number;
+    minZoom: number;
+    maxZoom: number;
+    zoomSpeed: number;
+    followSpeed: number;
+}
+
+// -- Options accepted by CinematicCameraPro.trackMultiple --
+export interface MultiTargetOptions {
+    paddingX?: number;
+    paddingY?: number;
+    padding?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    zoomSpeed?: number;
+    followSpeed?: number;
+}
+
+export declare function updateMultiTarget(
+    cam: CinematicCameraPro,
+    dt: number,
+    targets: Vec2[],
+    count: number,
+): void;
+export declare function createMultiTargetState(): MultiTargetState;
+
+declare const _default: typeof updateMultiTarget;
+export default _default;

package/src/ParallaxManager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @zakkster/lite-camera-pro/parallax -- TypeScript declarations.
+ *
+ * Multi-layer scroll manager. Pure math, no dependencies. Complete runtime
+ * surface, no `any`.
+ */
+
+// -- Wrap modes for layer tiling --
+export declare const WrapMode: {
+    readonly NONE: 0;
+    readonly REPEAT_X: 1;
+    readonly REPEAT_Y: 2;
+    readonly REPEAT_BOTH: 3;
+};
+
+// -- A single pre-allocated parallax layer --
+export interface ParallaxLayer {
+    active: boolean;
+    id: string;
+    speedX: number;
+    speedY: number;
+    offsetX: number;
+    offsetY: number;
+    wrap: number;
+    scrollX: number;
+    scrollY: number;
+}
+
+// -- Parallax manager state (one per camera) --
+export interface ParallaxState {
+    layers: ParallaxLayer[];
+    layerCount: number;
+    activeCount: number;
+}
+
+// -- Options accepted by addParallaxLayer --
+export interface ParallaxLayerOptions {
+    offsetX?: number;
+    offsetY?: number;
+    wrap?: number;
+}
+
+// -- Output shape for getLayerScroll --
+export interface ScrollOut {
+    x: number;
+    y: number;
+}
+
+export declare function createParallaxState(): ParallaxState;
+export declare function addParallaxLayer(
+    state: ParallaxState,
+    id: string,
+    speedX: number,
+    speedY?: number,
+    opts?: ParallaxLayerOptions,
+): ParallaxLayer | null;
+export declare function removeParallaxLayer(state: ParallaxState, id: string): void;
+export declare function updateParallax(state: ParallaxState, camX: number, camY: number, zoom: number): void;
+export declare function getLayerScroll(state: ParallaxState, id: string, out: ScrollOut): ScrollOut | null;
+export declare function applyParallaxLayer(state: ParallaxState, id: string, ctx: CanvasRenderingContext2D): boolean;

package/src/Shake.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @zakkster/lite-camera-pro/shake -- TypeScript declarations.
+ *
+ * The ./shake subpath barrel: the noise-based shake engine (ShakeEngine.js)
+ * plus the built-in presets and registry (ShakePresets.js). Complete runtime
+ * surface, no `any`.
+ */
+
+// -- Shake profile (input) --
+export interface ShakeProfile {
+    /** Initial trauma [0, 1]. Undefined defaults to 0.5 in addShake. */
+    trauma?: number;
+    /** Noise sample frequency (higher = more jittery). Default 15. */
+    freq?: number;
+    /** Trauma units lost per second. Default 1. */
+    decay?: number;
+    /** Maximum pixel offset at trauma=1. Default 15. */
+    maxOffset?: number;
+    /** Maximum rotation (radians) at trauma=1. Default 0.05. */
+    maxAngle?: number;
+    /** Directional X component; (0,0) = omnidirectional. Default 0. */
+    dirX?: number;
+    /** Directional Y component. Default 0. */
+    dirY?: number;
+    /** Per-profile intensity multiplier used by addShake. Default 1. */
+    intensity?: number;
+}
+
+// -- A single pre-allocated shake slot --
+export interface ShakeSlot {
+    active: boolean;
+    isDefault: boolean;
+    trauma: number;
+    decay: number;
+    freq: number;
+    time: number;
+    maxOffset: number;
+    maxAngle: number;
+    dirX: number;
+    dirY: number;
+    isDirectional: boolean;
+}
+
+// -- Shake engine state (one per camera) --
+export interface ShakeState {
+    slots: ShakeSlot[];
+    slotCount: number;
+    seedOffset: number;
+    /** Computed X offset in pixels (read by apply()). */
+    offsetX: number;
+    /** Computed Y offset in pixels. */
+    offsetY: number;
+    /** Computed rotation in radians. */
+    angle: number;
+    /** Global shake scale (0 = no shake, 1 = normal). */
+    globalScale: number;
+    /** True when any slot is active. */
+    active: boolean;
+}
+
+// -- Shake engine functions (ShakeEngine.js) --
+export declare function createShakeState(seedOffset?: number): ShakeState;
+export declare function addShake(state: ShakeState, profile: ShakeProfile, intensity?: number): void;
+export declare function addTraumaSimple(state: ShakeState, amount: number): void;
+export declare function updateShake(state: ShakeState, dt: number): void;
+export declare function computeShake(state: ShakeState): void;
+export declare function clearShakes(state: ShakeState): void;
+
+// -- Built-in presets (ShakePresets.js) --
+export declare const EXPLOSION: Readonly<ShakeProfile>;
+export declare const EARTHQUAKE: Readonly<ShakeProfile>;
+export declare const RECOIL: Readonly<ShakeProfile>;
+export declare const IMPACT: Readonly<ShakeProfile>;
+export declare const LANDING: Readonly<ShakeProfile>;
+export declare const DAMAGE: Readonly<ShakeProfile>;
+export declare const RUMBLE: Readonly<ShakeProfile>;
+export declare const HEAVY_IMPACT: Readonly<ShakeProfile>;
+
+// -- Preset registry (ShakePresets.js) --
+export declare function getPreset(name: string): Readonly<ShakeProfile> | null;
+export declare function registerPreset(name: string, profile: ShakeProfile): void;
+export declare function listPresets(): string[];

package/src/Shake.js

@@ -0,0 +1,7 @@
+// @zakkster/lite-camera-pro -- the ./shake subpath barrel.
+// Re-export only; never a copy. The camera class and this subpath import the
+// SAME module files, so createShakeState et al. have one runtime identity.
+// ShakePresets is folded in so a shake-only consumer gets presets + getPreset
+// from a single import.
+export * from './ShakeEngine.js';
+export * from './ShakePresets.js';

package/src/index.d.ts

@@ -1,68 +1,27 @@
 /**
- * @zakkster/lite-camera-pro — TypeScript Declarations
+ * @zakkster/lite-camera-pro -- TypeScript declarations (main entry).
+ *
+ * The full functional layer is re-exported from the per-subsystem sibling
+ * declarations (one declaration per type -- no duplicates). This file adds the
+ * CinematicCameraPro class, the debug-HUD facade, and the VERSION const.
  */
 
-// ── Follow Modes ──
-export declare const FollowMode: {
-    readonly SMOOTH: 0;
-    readonly LOCK: 1;
-    readonly PREDICTIVE: 2;
-    readonly CUT: 3;
-    readonly HYBRID: 4;
-};
-
-export declare const FOLLOW_STRATEGIES: ReadonlyArray<
-    (cam: CinematicCameraPro, dt: number, px: number, py: number, pvx: number, pvy: number) => void
->;
-
-// ── Wrap Modes ──
-export declare const WrapMode: {
-    readonly NONE: 0;
-    readonly REPEAT_X: 1;
-    readonly REPEAT_Y: 2;
-    readonly REPEAT_BOTH: 3;
-};
-
-// ── Bounds Types ──
-export declare const BoundsType: {
-    readonly HARD: 0;
-    readonly SOFT: 1;
-    readonly ELASTIC: 2;
-    readonly NONE: 3;
-};
-
-// ── Shake Profile ──
-export interface ShakeProfile {
-    trauma?: number;
-    freq?: number;
-    decay?: number;
-    maxOffset?: number;
-    maxAngle?: number;
-    dirX?: number;
-    dirY?: number;
-}
-
-// ── Shake Presets ──
-export declare const EXPLOSION: Readonly<ShakeProfile>;
-export declare const EARTHQUAKE: Readonly<ShakeProfile>;
-export declare const RECOIL: Readonly<ShakeProfile>;
-export declare const IMPACT: Readonly<ShakeProfile>;
-export declare const LANDING: Readonly<ShakeProfile>;
-export declare const DAMAGE: Readonly<ShakeProfile>;
-export declare const RUMBLE: Readonly<ShakeProfile>;
-export declare const HEAVY_IMPACT: Readonly<ShakeProfile>;
-
-export declare function getPreset(name: string): ShakeProfile | null;
-export declare function registerPreset(name: string, profile: ShakeProfile): void;
-export declare function listPresets(): string[];
-
-// ── Vec2 ──
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-
-// ── Debug HUD Config ──
+// -- Functional layer (mirrors the ./shake, ./parallax, ./bounds, ./multi,
+//    ./follow, ./sequence subpaths; same runtime identities) --
+export * from './Shake.js';
+export * from './ParallaxManager.js';
+export * from './BoundsSystem.js';
+export * from './MultiTarget.js';
+export * from './FollowMode.js';
+export * from './CameraSequence.js';
+
+// -- Types needed locally by the class declaration --
+import type { ShakeProfile } from './Shake.js';
+import type { Vec2, MultiTargetOptions } from './MultiTarget.js';
+import type { BoundsEdgesConfig } from './BoundsSystem.js';
+import type { CameraSequence, CameraSequenceOptions } from './CameraSequence.js';
+
+// -- Debug HUD (DebugHUD.js) -- facade only, no dedicated subpath --
 export interface DebugHUDConfig {
     show: {
         position: boolean;
@@ -83,66 +42,14 @@ export declare function createDebugHUDConfig(): DebugHUDConfig;
 export declare function drawDebugHUD(cam: CinematicCameraPro, ctx: CanvasRenderingContext2D, config?: DebugHUDConfig): void;
 export declare function drawDebugWorld(cam: CinematicCameraPro, ctx: CanvasRenderingContext2D, config?: DebugHUDConfig): void;
 
-// ── Camera Sequence ──
-export interface CameraSequenceOptions {
-    loop?: boolean;
-    onComplete?: () => void;
-    blendOutTime?: number;
-}
-
-export interface StepOptions {
-    ease?: (t: number) => number;
-    at?: string | number;
-}
-
-export interface CameraSequence {
-    moveTo(x: number, y: number, duration: number, opts?: StepOptions): CameraSequence;
-    zoomTo(level: number, duration: number, opts?: StepOptions): CameraSequence;
-    moveAndZoom(x: number, y: number, level: number, duration: number, opts?: StepOptions): CameraSequence;
-    shake(profileOrName: string | ShakeProfile, intensity?: number, opts?: StepOptions): CameraSequence;
-    wait(duration: number, opts?: StepOptions): CameraSequence;
-    call(fn: () => void, opts?: StepOptions): CameraSequence;
-    play(): CameraSequence;
-    pause(): CameraSequence;
-    resume(): CameraSequence;
-    stop(): CameraSequence;
-    seek(timeMs: number): CameraSequence;
-    destroy(): void;
-    readonly duration: number;
-    readonly progress: number;
-    readonly playing: boolean;
-}
-
-export declare function createCameraSequence(cam: CinematicCameraPro, options?: CameraSequenceOptions): CameraSequence;
-export declare function panTo(cam: CinematicCameraPro, x: number, y: number, duration: number, opts?: CameraSequenceOptions & StepOptions): CameraSequence;
-export declare function dramaticZoom(cam: CinematicCameraPro, x: number, y: number, zoom: number, duration: number, opts?: CameraSequenceOptions & StepOptions): CameraSequence;
-export declare function bossReveal(cam: CinematicCameraPro, x: number, y: number, totalMs?: number, opts?: CameraSequenceOptions): CameraSequence;
-export declare function timedShake(cam: CinematicCameraPro, presetOrProfile: string | ShakeProfile, holdMs?: number, opts?: CameraSequenceOptions): CameraSequence;
-
-// ── Multi-Target Options ──
-export interface MultiTargetOptions {
-    paddingX?: number;
-    paddingY?: number;
-    padding?: number;
-    minZoom?: number;
-    maxZoom?: number;
-    zoomSpeed?: number;
-    followSpeed?: number;
-}
-
-// ── Bounds Config ──
-export interface BoundsEdgesConfig {
-    left?: number;
-    right?: number;
-    top?: number;
-    bottom?: number;
-}
+// -- Package version (bumped in lockstep with package.json + llms.txt) --
+export declare const VERSION: string;
 
-// ── Main Camera Class ──
+// -- Main camera class --
 export declare class CinematicCameraPro {
     constructor(viewW: number, viewH: number, worldW: number, worldH: number, seed?: number);
 
-    // ── Public state ──
+    // Public state
     readonly pos: Float32Array;
     readonly target: Float32Array;
     readonly look: Float32Array;
@@ -170,58 +77,58 @@ export declare class CinematicCameraPro {
 
     debugConfig: DebugHUDConfig;
 
-    // ── Follow Mode ──
+    // Follow mode
     setMode(mode: number): this;
 
-    // ── Multi-Target ──
+    // Multi-target
     trackMultiple(targets: Vec2[], options?: MultiTargetOptions): this;
     trackSingle(): this;
     setTargetCount(count: number): this;
 
-    // ── Shake ──
+    // Shake
     addTrauma(amount: number): this;
     shake(profile: ShakeProfile, intensity?: number): this;
     shakePreset(name: string, intensity?: number): this;
     clearShakes(): this;
 
-    // ── Sequences ──
+    // Sequences
     createSequence(options?: CameraSequenceOptions): CameraSequence;
     playSequence(seq: CameraSequence): this;
     stopSequence(): this;
     readonly sequencePlaying: boolean;
 
-    // ── Zoom ──
+    // Zoom
     setZoom(level: number, duration?: number, ease?: (t: number) => number): this;
     zoomAt(targetOrX: number | Vec2, yOrLevel: number, levelOrDur?: number, duration?: number, ease?: (t: number) => number): this;
 
-    // ── Coordinate Conversion ──
+    // Coordinate conversion
     screenToWorld(sx: number, sy: number, out: Vec2): Vec2;
     worldToScreen(wx: number, wy: number, out: Vec2): Vec2;
 
-    // ── Parallax ──
+    // Parallax
     addParallaxLayer(id: string, speedX: number, speedY?: number, opts?: { offsetX?: number; offsetY?: number; wrap?: number }): this;
     removeParallaxLayer(id: string): this;
     applyParallax(id: string, ctx: CanvasRenderingContext2D): boolean;
 
-    // ── Bounds ──
+    // Bounds
     setBoundsType(type: number): this;
     setBoundsEdges(config: BoundsEdgesConfig): this;
     setBoundsRect(x: number, y: number, w: number, h: number): this;
     clearBoundsRect(): this;
 
-    // ── Core ──
+    // Core
     update(dt: number, px: number, py: number, pvx?: number, pvy?: number): void;
     apply(ctx: CanvasRenderingContext2D): void;
 
-    // ── Debug ──
+    // Debug
     debug(ctx: CanvasRenderingContext2D): void;
     debugHUD(ctx: CanvasRenderingContext2D): void;
 
-    // ── Save / Load ──
+    // Save / load
     getState(): { posX: number; posY: number; targetX: number; targetY: number; zoom: number; mode: number };
     setState(snapshot: { posX?: number; posY?: number; targetX?: number; targetY?: number; zoom?: number; mode?: number }): this;
 
-    // ── Lifecycle ──
+    // Lifecycle
     destroy(): void;
 }
 

package/src/index.js

@@ -6,7 +6,7 @@
  * Zero external dependencies outside the @zakkster ecosystem.
  */
 
-export const VERSION = "1.0.1";
+export const VERSION = "1.1.0";
 
 // -- Core --
 export { CinematicCameraPro } from './CinematicCameraPro.js';