@bookklik/pivo-plate 0.0.0-stage → 0.2.0

package/lib/core.d.ts

@@ -0,0 +1,165 @@
+import { g as Project, h as Selection, B as Brush, A as Atlas, V as Vec2, E as EditorSession, i as Vec3, T as Tile, c as Plane } from './types/png-CEL_ylyR.js';
+export { a as AtlasRegion, D as DEFAULT_OBJECT_ID, M as Mode, P as PNG_LIMITS, b as PROJECT_PNG_LIMITS, d as PngAlphaMode, e as PngInfo, f as PngLimits, S as SceneObject, p as pngBytesDataUrl, j as pngDataUrlBytes, v as validatePngBytes, k as validatePngDataUrl } from './types/png-CEL_ylyR.js';
+
+/** Hard cap on parent-chain depth for any object in a valid project. */
+declare const MAX_HIERARCHY_DEPTH = 128;
+
+/** Generate a reasonably unique id, optionally prefixed. */
+declare function uid(prefix?: string): string;
+declare function clone<T>(value: T): T;
+declare function v3(x: number, y: number, z: number): Vec3;
+/** Create a new, empty project with the default object-main object. */
+declare function createProject(name?: string): Project;
+/**
+ * Create an editing session for a project. Projects may have no atlases yet;
+ * in that case the session falls back to a blank brush referencing a
+ * conventional blank atlas id, so drawing can still start from nothing.
+ */
+declare function createSession(project: Project): EditorSession;
+/**
+ * Snap a scalar to the nearest multiple of `grid`. Grid 0 or negative grid
+ * falls back to identity (no snapping). Works correctly for negatives.
+ */
+declare function snap(value: number, grid: number): number;
+/**
+ * Map a point onto the given construction plane: the two in-plane
+ * coordinates are floor-snapped to the cell origin (lower corner of the
+ * grid cell containing the point), and the perpendicular coordinate is
+ * taken from the crosshair so drawing happens at the current elevation.
+ * Right-handed Y-up: XZ is the ground plane, XY and YZ are wall planes.
+ */
+declare function planePoint(point: Vec3, plane: Plane, crosshair: Vec3, grid: number): Vec3;
+/**
+ * World-space quad corners for a tile whose origin corner sits at `origin`
+ * on the given plane, sized `tileSize`. Corner order is consistent across
+ * planes: [origin, +a, +a+b, +b] where (a, b) are the plane's in-plane axes
+ * chosen so the triangulation [0,1,2,0,2,3] faces the plane's positive
+ * axis under right-handed Y-up coordinates:
+ *   XY → +Z (a=x, b=y), XZ → +Y (a=z, b=x), YZ → +X (a=y, b=z).
+ */
+declare function tileCorners(origin: Vec3, plane: Plane, tileSize: number): [Vec3, Vec3, Vec3, Vec3];
+/**
+ * Validate a brush against its atlas before any tile is created or mutated:
+ * region must be a finite in-bounds pixel rectangle with positive size, and
+ * rotation must be a whole number of quarter-turns (0..3). Called by
+ * makeTile/applyBrush so invalid brushes are rejected before mutation.
+ */
+declare function validateBrushAgainstAtlas(atlas: Atlas, brush: Brush): void;
+/**
+ * Create a tile on the active object at `origin` on the session plane,
+ * using the session brush for UVs. Mutates the project in place (intended
+ * to be called inside a store transaction) and returns the new tile.
+ * Rejects out-of-bounds brush regions and invalid rotation flags before
+ * any tile is created.
+ */
+declare function makeTile(project: Project, session: EditorSession, origin: Vec3): Tile;
+/**
+ * Convert a brush pixel-region (top-down y, like image space) plus
+ * rotation/flips into four bottom-left-origin UVs matching the quad corner
+ * order [LL, LR, UR, UL]. Rotation is in quarter-turns, clockwise in image
+ * space. Margins/spacing describe *selectable cells* and do not shrink the
+ * requested region itself.
+ */
+declare function brushUVs(atlas: Atlas, brush: Brush): [Vec2, Vec2, Vec2, Vec2];
+/** True when the object or any of its ancestors is locked. */
+declare function isObjectLocked(project: Project, id: string): boolean;
+/** Ancestor visibility with a defensive cycle/depth guard. */
+declare function isObjectVisible(project: Project, id: string): boolean;
+/** Reparent an object. Rejects cycles (including self-parenting). */
+declare function reparentObject(project: Project, id: string, parentId: string | null): void;
+/** Deduplicated list of selected corners with their owning tiles. */
+declare function selectedCorners(project: Project, selection: Selection): {
+    tile: Tile;
+    corner: number;
+}[];
+declare function translateSelection(project: Project, selection: Selection, delta: Vec3): void;
+declare function rotateSelection(project: Project, selection: Selection, axis: 'x' | 'y' | 'z', radians: number, pivot: Vec3): void;
+declare function scaleSelection(project: Project, selection: Selection, factor: Vec3, pivot: Vec3): void;
+/** Duplicate selected tiles, offset by `delta`. Returns new tile ids. */
+declare function duplicateSelection(project: Project, selection: Selection, delta: Vec3): string[];
+/** Delete the selected tiles. Corner-only selections are rejected. */
+declare function deleteSelection(project: Project, selection: Selection): void;
+/** Reverse winding of selected tiles. */
+declare function reverseSelection(project: Project, selection: Selection): void;
+/** Apply the session brush's UVs (via given brush) to selected tiles.
+ * The whole brush is validated (region bounds, rotation flags) before any
+ * tile is mutated, so a rejected brush leaves every tile untouched. */
+declare function applyBrush(project: Project, selection: Selection, brush: Brush): void;
+/**
+ * Shared UV range policy: UVs must lie in the closed 0..1 range, with this
+ * explicit tolerance for floating-point drift. Values within tolerance are
+ * normalized (clamped) back to the exact bound; beyond tolerance is invalid.
+ */
+declare const UV_TOLERANCE = 0.000001;
+/** Validate one UV pair against the shared 0..1 policy; readable message. */
+declare function checkUvInRange(tileId: string, uv: Vec2): void;
+/** Normalize (clamp) UV components that drifted within tolerance back into 0..1. */
+declare function normalizeUv(uv: Vec2): Vec2;
+/**
+ * Transform UVs of selected tiles. `rotate` turns UVs 90° clockwise around
+ * the tile's UV center; flips mirror across the center; `offset` (when
+ * provided) translates all four UVs afterwards. All per-tile results are
+ * computed up front and the offset is validated BEFORE any tile is mutated,
+ * so a rejected operation (e.g. a non-finite offset) leaves every tile
+ * untouched. Range enforcement of the RESULT happens at the document
+ * boundary: validateProject / EditorStore.transact reject UVs outside the
+ * shared 0..1 policy, so an offset that would leave the range can never be
+ * committed through a transaction.
+ */
+declare function transformUVs(project: Project, selection: Selection, operation: 'rotate' | 'flipX' | 'flipY', offset?: Vec2): void;
+/**
+ * Validate an unknown value as a Project. Returns a deep clone on success.
+ * Throws a readable Error on any structural problem. Never mutates input.
+ */
+declare function validateProject(value: unknown): Project;
+/**
+ * Snapshot-based transactional store. Every successful transaction pushes an
+ * immutable structural snapshot onto the undo stack; failed (throwing)
+ * transactions leave state untouched; no-op transactions (deep-equal result)
+ * are omitted from history. Undo/redo history is bounded.
+ */
+declare class EditorStore {
+    private readonly historyBudget;
+    private _project;
+    private _undoStack;
+    private _redoStack;
+    private _label;
+    private _revision;
+    private _savedSnapshot;
+    private _listeners;
+    private historyCosts;
+    constructor(project: Project, historyBudget?: number);
+    get project(): Project;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    /** Label of the most recent committed transaction ('' if none yet). */
+    get historyLabel(): string;
+    /** Monotonically increasing counter bumped on every state change. */
+    get revision(): number;
+    /** Semantic dirty flag: current state differs from last saved state. */
+    get dirty(): boolean;
+    subscribe(fn: () => void): () => void;
+    private emit;
+    private pushHistory;
+    get retainedHistoryBytes(): number;
+    /**
+     * Run a synchronous mutation. The callback receives a working draft; the
+     * raw draft is validated with the canonical validator BEFORE publication
+     * and before JSON cloning could mask NaN/Infinity (which stringify to
+     * null). On validation failure or throw, state, revision, history, redo
+     * and dirty state are untouched. The committed project is re-cloned so no
+     * retained reference to the draft (including a callback that keeps mutating
+     * asynchronously after rejection or resolution) can alias committed state.
+     */
+    transact(label: string, fn: (project: Project) => void): void;
+    undo(): void;
+    redo(): void;
+    /** Replace the whole project (e.g. load). Validates BEFORE replacing the
+     * current project: on invalid input the existing state, history, revision
+     * and dirty flags are untouched. Clears undo/redo history on success. */
+    replace(project: Project): void;
+    /** Mark the snapshot actually downloaded; edits during a save stay dirty. */
+    markSaved(snapshot?: Project): void;
+}
+
+export { Atlas, Brush, EditorSession, EditorStore, MAX_HIERARCHY_DEPTH, Plane, Project, Selection, Tile, UV_TOLERANCE, Vec2, Vec3, applyBrush, brushUVs, checkUvInRange, clone, createProject, createSession, deleteSelection, duplicateSelection, isObjectLocked, isObjectVisible, makeTile, normalizeUv, planePoint, reparentObject, reverseSelection, rotateSelection, scaleSelection, selectedCorners, snap, tileCorners, transformUVs, translateSelection, uid, v3, validateBrushAgainstAtlas, validateProject };

package/lib/core.js

@@ -0,0 +1,75 @@
+import "./chunks/chunk-C4CNHGLY.js";
+import {
+  EditorStore,
+  MAX_HIERARCHY_DEPTH,
+  PNG_LIMITS,
+  PROJECT_PNG_LIMITS,
+  UV_TOLERANCE,
+  applyBrush,
+  brushUVs,
+  checkUvInRange,
+  clone,
+  createProject,
+  createSession,
+  deleteSelection,
+  duplicateSelection,
+  isObjectLocked,
+  isObjectVisible,
+  makeTile,
+  normalizeUv,
+  planePoint,
+  pngBytesDataUrl,
+  pngDataUrlBytes,
+  reparentObject,
+  reverseSelection,
+  rotateSelection,
+  scaleSelection,
+  selectedCorners,
+  snap,
+  tileCorners,
+  transformUVs,
+  translateSelection,
+  uid,
+  v3,
+  validateBrushAgainstAtlas,
+  validatePngBytes,
+  validatePngDataUrl,
+  validateProject
+} from "./chunks/chunk-OYM3ZMMA.js";
+export {
+  EditorStore,
+  MAX_HIERARCHY_DEPTH,
+  PNG_LIMITS,
+  PROJECT_PNG_LIMITS,
+  UV_TOLERANCE,
+  applyBrush,
+  brushUVs,
+  checkUvInRange,
+  clone,
+  createProject,
+  createSession,
+  deleteSelection,
+  duplicateSelection,
+  isObjectLocked,
+  isObjectVisible,
+  makeTile,
+  normalizeUv,
+  planePoint,
+  pngBytesDataUrl,
+  pngDataUrlBytes,
+  reparentObject,
+  reverseSelection,
+  rotateSelection,
+  scaleSelection,
+  selectedCorners,
+  snap,
+  tileCorners,
+  transformUVs,
+  translateSelection,
+  uid,
+  v3,
+  validateBrushAgainstAtlas,
+  validatePngBytes,
+  validatePngDataUrl,
+  validateProject
+};

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { EditorStore, MAX_HIERARCHY_DEPTH, UV_TOLERANCE, applyBrush, brushUVs, checkUvInRange, clone, createProject, createSession, deleteSelection, duplicateSelection, isObjectLocked, isObjectVisible, makeTile, normalizeUv, planePoint, reparentObject, reverseSelection, rotateSelection, scaleSelection, selectedCorners, snap, tileCorners, transformUVs, translateSelection, uid, v3, validateBrushAgainstAtlas, validateProject } from './core.js';
+export { A as Atlas, a as AtlasRegion, B as Brush, D as DEFAULT_OBJECT_ID, E as EditorSession, M as Mode, P as PNG_LIMITS, b as PROJECT_PNG_LIMITS, c as Plane, d as PngAlphaMode, e as PngInfo, f as PngLimits, g as Project, S as SceneObject, h as Selection, T as Tile, V as Vec2, i as Vec3, p as pngBytesDataUrl, j as pngDataUrlBytes, v as validatePngBytes, k as validatePngDataUrl } from './types/png-CEL_ylyR.js';
+export { ContainerError, ExportError, PayloadError, ProjectIOError, decodeProject, encodeProject, exportGLB, exportOBJ, inspectAlpha } from './io.js';

package/lib/index.js

@@ -0,0 +1,95 @@
+import "./chunks/chunk-C4CNHGLY.js";
+import {
+  ContainerError,
+  ExportError,
+  PayloadError,
+  ProjectIOError,
+  decodeProject,
+  encodeProject,
+  exportGLB,
+  exportOBJ,
+  inspectAlpha
+} from "./chunks/chunk-DKWUGCIO.js";
+import {
+  EditorStore,
+  MAX_HIERARCHY_DEPTH,
+  PNG_LIMITS,
+  PROJECT_PNG_LIMITS,
+  UV_TOLERANCE,
+  applyBrush,
+  brushUVs,
+  checkUvInRange,
+  clone,
+  createProject,
+  createSession,
+  deleteSelection,
+  duplicateSelection,
+  isObjectLocked,
+  isObjectVisible,
+  makeTile,
+  normalizeUv,
+  planePoint,
+  pngBytesDataUrl,
+  pngDataUrlBytes,
+  reparentObject,
+  reverseSelection,
+  rotateSelection,
+  scaleSelection,
+  selectedCorners,
+  snap,
+  tileCorners,
+  transformUVs,
+  translateSelection,
+  uid,
+  v3,
+  validateBrushAgainstAtlas,
+  validatePngBytes,
+  validatePngDataUrl,
+  validateProject
+} from "./chunks/chunk-OYM3ZMMA.js";
+export {
+  ContainerError,
+  EditorStore,
+  ExportError,
+  MAX_HIERARCHY_DEPTH,
+  PNG_LIMITS,
+  PROJECT_PNG_LIMITS,
+  PayloadError,
+  ProjectIOError,
+  UV_TOLERANCE,
+  applyBrush,
+  brushUVs,
+  checkUvInRange,
+  clone,
+  createProject,
+  createSession,
+  decodeProject,
+  deleteSelection,
+  duplicateSelection,
+  encodeProject,
+  exportGLB,
+  exportOBJ,
+  inspectAlpha,
+  isObjectLocked,
+  isObjectVisible,
+  makeTile,
+  normalizeUv,
+  planePoint,
+  pngBytesDataUrl,
+  pngDataUrlBytes,
+  reparentObject,
+  reverseSelection,
+  rotateSelection,
+  scaleSelection,
+  selectedCorners,
+  snap,
+  tileCorners,
+  transformUVs,
+  translateSelection,
+  uid,
+  v3,
+  validateBrushAgainstAtlas,
+  validatePngBytes,
+  validatePngDataUrl,
+  validateProject
+};

package/lib/io.d.ts

@@ -0,0 +1,40 @@
+import { Project, PngAlphaMode } from './core.js';
+
+/**
+ * Encode a project into a versioned .pvp archive:
+ *   project.json          — the Project document (format/version/name/…)
+ *   atlases/<id>.png      — each atlas texture as a real PNG
+ * Atlas.dataUrl is not stored redundantly; decodeProject restores it from the
+ * extracted PNG bytes, preserving pixel-exact atlas data.
+ */
+declare function encodeProject(project: Project): Promise<Uint8Array>;
+/**
+ * Decode a .pvp archive into a validated Project. Throws
+ * ContainerError / PayloadError with readable messages for invalid archives.
+ * On success the returned Project is fully independent of the input bytes.
+ */
+declare function decodeProject(bytes: Uint8Array): Promise<Project>;
+
+/** Thrown for any readable IO failure (container, autosave, validation). */
+declare class ProjectIOError extends Error {
+    constructor(message: string);
+}
+/** Container-level failures: bad ZIP, wrong format marker, disallowed paths. */
+declare class ContainerError extends ProjectIOError {
+    constructor(message: string);
+}
+/** Thrown when a payload (project.json, embedded PNG) fails validation. */
+declare class PayloadError extends ProjectIOError {
+    constructor(message: string);
+}
+/** Export failures: invalid geometry, no visible content, loader errors. */
+declare class ExportError extends ProjectIOError {
+    constructor(message: string);
+}
+
+declare function exportOBJ(project: Project, inspectedAlpha?: Map<string, 'opaque' | 'cutout' | 'blend'>): Promise<Uint8Array>;
+declare function exportGLB(project: Project, inspectedAlpha?: Map<string, 'opaque' | 'cutout' | 'blend'>): Promise<Uint8Array>;
+
+declare function inspectAlpha(project: Project): Promise<Map<string, PngAlphaMode>>;
+
+export { ContainerError, ExportError, PayloadError, ProjectIOError, decodeProject, encodeProject, exportGLB, exportOBJ, inspectAlpha };

package/lib/io.js

@@ -0,0 +1,23 @@
+import {
+  ContainerError,
+  ExportError,
+  PayloadError,
+  ProjectIOError,
+  decodeProject,
+  encodeProject,
+  exportGLB,
+  exportOBJ,
+  inspectAlpha
+} from "./chunks/chunk-DKWUGCIO.js";
+import "./chunks/chunk-OYM3ZMMA.js";
+export {
+  ContainerError,
+  ExportError,
+  PayloadError,
+  ProjectIOError,
+  decodeProject,
+  encodeProject,
+  exportGLB,
+  exportOBJ,
+  inspectAlpha
+};

package/lib/types/png-CEL_ylyR.d.ts

@@ -0,0 +1,122 @@
+type Vec3 = [number, number, number];
+type Vec2 = [number, number];
+type Plane = 'XY' | 'XZ' | 'YZ';
+type Mode = 'draw' | 'edit';
+interface Atlas {
+    id: string;
+    name: string;
+    width: number;
+    height: number;
+    tileWidth: number;
+    tileHeight: number;
+    margin: number;
+    spacing: number;
+    dataUrl: string;
+}
+interface AtlasRegion {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface Tile {
+    id: string;
+    objectId: string;
+    atlasId: string;
+    vertices: [Vec3, Vec3, Vec3, Vec3];
+    uvs: [Vec2, Vec2, Vec2, Vec2];
+    reversed: boolean;
+}
+interface SceneObject {
+    id: string;
+    name: string;
+    parentId: string | null;
+    visible: boolean;
+    locked: boolean;
+}
+interface Project {
+    format: 'pivo-plate';
+    version: 1;
+    name: string;
+    atlases: Atlas[];
+    objects: SceneObject[];
+    tiles: Tile[];
+}
+interface Selection {
+    tileIds: string[];
+    vertices: {
+        tileId: string;
+        corner: number;
+    }[];
+}
+interface Brush {
+    atlasId: string;
+    region: AtlasRegion;
+    rotation: 0 | 1 | 2 | 3;
+    flipX: boolean;
+    flipY: boolean;
+}
+interface EditorSession {
+    mode: Mode;
+    crosshair: Vec3;
+    plane: Plane;
+    planeLocked: boolean;
+    grid: number;
+    tileSize: number;
+    activeObjectId: string;
+    brush: Brush;
+    selection: Selection;
+}
+declare const DEFAULT_OBJECT_ID = "object-main";
+
+declare const PNG_LIMITS: Readonly<{
+    maxBytes: number;
+    maxDimension: 16384;
+    maxPixels: 16777216;
+    maxInflatedBytes: number;
+    maxChunks: 4096;
+    maxAncillaryBytes: number;
+    maxMetadataInflatedBytes: number;
+}>;
+declare const PROJECT_PNG_LIMITS: Readonly<{
+    maxPngBytes: number;
+    maxPixels: 33554432;
+    maxInflatedBytes: number;
+    maxManifestBytes: number;
+}>;
+interface PngLimits {
+    maxBytes: number;
+    maxDimension: number;
+    maxPixels: number;
+    maxInflatedBytes: number;
+    maxChunks: number;
+    maxAncillaryBytes: number;
+    maxMetadataInflatedBytes: number;
+}
+type PngAlphaMode = 'opaque' | 'cutout' | 'blend';
+interface PngInfo {
+    width: number;
+    height: number;
+    bitDepth: number;
+    colorType: number;
+    interlace: number;
+    byteLength: number;
+    inflatedBytes: number;
+    chunks: number;
+    ancillaryBytes: number;
+    alphaMode?: PngAlphaMode;
+}
+declare function validatePngBytes(bytes: Uint8Array, expected?: {
+    width: number;
+    height: number;
+}, overrides?: Partial<PngLimits>): PngInfo;
+/** Strict base64 decoded-size checks happen BEFORE allocating binary data. */
+declare function pngDataUrlBytes(url: string): Uint8Array;
+declare function pngBytesDataUrl(bytes: Uint8Array): string;
+declare function validatePngDataUrl(url: string, expected?: {
+    width: number;
+    height: number;
+}): PngInfo;
+
+export { DEFAULT_OBJECT_ID as D, PNG_LIMITS as P, PROJECT_PNG_LIMITS as b, pngDataUrlBytes as j, validatePngDataUrl as k, pngBytesDataUrl as p, validatePngBytes as v };
+export type { Atlas as A, Brush as B, EditorSession as E, Mode as M, SceneObject as S, Tile as T, Vec2 as V, AtlasRegion as a, Plane as c, PngAlphaMode as d, PngInfo as e, PngLimits as f, Project as g, Selection as h, Vec3 as i };

package/package.json

@@ -1,6 +1,131 @@
 {
   "name": "@bookklik/pivo-plate",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "license": "MIT",
+  "author": "a-hakim",
+  "private": false,
+  "type": "module",
+  "description": "A local-first browser tile-to-3D modeling editor.",
+  "scripts": {
+    "dev": "vite --host 0.0.0.0",
+    "build": "tsc --noEmit && vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:browser": "node scripts/browser-readiness.mjs",
+    "test:layout": "node tests/layout-check.mjs",
+    "test:safety": "node tests/browser-safety.mjs",
+    "test:modeling": "node tests/browser-modeling.mjs",
+    "test:png": "node tests/browser-png.mjs",
+    "test:erase-hud": "node tests/browser-erase-hud.mjs",
+    "test:theme": "node tests/browser-theme.mjs",
+    "test:font": "node tests/browser-font.mjs",
+    "build:standalone": "node scripts/build-standalone.mjs",
+    "preview": "vite preview --host 0.0.0.0",
+    "docs:dev": "npm run docs:build && node scripts/preview-docs.mjs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "docs:capture": "node scripts/capture-tutorials.mjs",
+    "check:suite": "node scripts/check-suite.mjs",
+    "check:dependencies": "node scripts/audit-dependencies.mjs",
+    "test:release": "node scripts/browser-readiness.mjs",
+    "test:browser:legacy": "node tests/browser-e2e.mjs",
+    "capture:predecessor": "node scripts/capture-predecessor.mjs",
+    "test:upgrade": "node scripts/browser-upgrade.mjs",
+    "test:standalone": "node scripts/browser-standalone.mjs",
+    "test:workers": "node scripts/browser-workers.mjs",
+    "test:menus": "node scripts/browser-menus.mjs",
+    "build:lib": "node scripts/build-library.mjs",
+    "check:package": "node scripts/check-package.mjs",
+    "check:consumer": "node scripts/check-consumer.mjs",
+    "prepack": "npm run build:lib && npm run check:package",
+    "prepublishOnly": "npm run check:dependencies",
+    "release:check": "npm run check:dependencies && npm run build && npm run docs:build && npm run build:lib && npm run check:package && npm run check:consumer"
+  },
+  "dependencies": {
+    "fflate": "0.8.3",
+    "pako": "^2.2.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "1.64.0",
+    "@types/node": "^24.19.1",
+    "@types/pako": "^2.0.4",
+    "@types/three": "^0.180.0",
+    "@vitest/coverage-v8": "5.0.4",
+    "fake-indexeddb": "6.2.5",
+    "typescript": "^5.9.3",
+    "vite": "7.3.7",
+    "vite-plugin-pwa": "^2.0.0",
+    "vitepress": "^1.6.4",
+    "vitest": "5.0.4",
+    "@fontsource-variable/outfit": "^5.3.0",
+    "lucide": "^1.54.0",
+    "three": "^0.180.0",
+    "esbuild": "0.28.2",
+    "rollup": "4.65.1",
+    "rollup-plugin-dts": "6.5.1"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "packageManager": "npm@11.19.0",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./headless": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./core": {
+      "types": "./lib/core.d.ts",
+      "import": "./lib/core.js",
+      "default": "./lib/core.js"
+    },
+    "./io": {
+      "types": "./lib/io.d.ts",
+      "import": "./lib/io.js",
+      "default": "./lib/io.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "LICENSE",
+    "README.md",
+    "docs/npm.md",
+    "THIRD_PARTY_NOTICES.md",
+    "docs/licenses"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bookklik-technologies/pivo-plate.git"
+  },
+  "homepage": "https://bookklik-technologies.github.io/pivo-plate/docs/",
+  "bugs": {
+    "url": "https://github.com/bookklik-technologies/pivo-plate/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "pivo",
+    "headless",
+    "3d",
+    "editor"
+  ],
+  "overrides": {
+    "fast-uri": "3.1.9",
+    "serialize-javascript": "7.1.3",
+    "vitepress": {
+      "vite": "6.4.5"
+    }
+  }
+}