@kite3d/engine 0.15.0

package/dist/migrations.js

@@ -0,0 +1,5 @@
+const o = [];
+export {
+  o as PROJECT_MIGRATIONS
+};
+//# sourceMappingURL=migrations.js.map

package/dist/migrations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.js","sources":["../src/runtime/migrations.ts"],"sourcesContent":["export interface ProjectMigration {\n    version: string\n    migrate(projectRoot: string): void | Promise<void>\n}\n\nexport const PROJECT_MIGRATIONS: readonly ProjectMigration[] = []\n"],"names":["PROJECT_MIGRATIONS"],"mappings":"AAKO,MAAMA,IAAkD,CAAA;"}

package/dist/paths.d.ts

@@ -0,0 +1,9 @@
+export declare const KITE3D_DIRECTORY = ".kite3d";
+export declare const DEPLOYS_PATH = ".kite3d/deploys.json";
+export declare const JOURNAL_PATH = ".kite3d/journal.jsonl";
+export declare const STATE_PATH = ".kite3d/state.json";
+export declare const CONSOLE_PATH = ".kite3d/console.log";
+export declare const THUMBS_DIRECTORY = ".kite3d/thumbs";
+export declare const BACKUPS_DIRECTORY = ".kite3d/backups";
+export declare const RUNNING_DIRECTORY = ".kite3d/running";
+export declare const KITE3D_SERVER_CLIENT_ID = "kite3d-server";

package/dist/paths.js

@@ -0,0 +1,13 @@
+const o = ".kite3d", s = `${o}/deploys.json`, n = `${o}/journal.jsonl`, t = `${o}/state.json`, T = `${o}/console.log`, E = `${o}/thumbs`, R = `${o}/backups`, c = `${o}/running`, _ = "kite3d-server";
+export {
+  R as BACKUPS_DIRECTORY,
+  T as CONSOLE_PATH,
+  s as DEPLOYS_PATH,
+  n as JOURNAL_PATH,
+  o as KITE3D_DIRECTORY,
+  _ as KITE3D_SERVER_CLIENT_ID,
+  c as RUNNING_DIRECTORY,
+  t as STATE_PATH,
+  E as THUMBS_DIRECTORY
+};
+//# sourceMappingURL=paths.js.map

package/dist/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","sources":["../src/paths.ts"],"sourcesContent":["export const KITE3D_DIRECTORY = '.kite3d'\nexport const DEPLOYS_PATH = `${KITE3D_DIRECTORY}/deploys.json`\nexport const JOURNAL_PATH = `${KITE3D_DIRECTORY}/journal.jsonl`\nexport const STATE_PATH = `${KITE3D_DIRECTORY}/state.json`\nexport const CONSOLE_PATH = `${KITE3D_DIRECTORY}/console.log`\nexport const THUMBS_DIRECTORY = `${KITE3D_DIRECTORY}/thumbs`\nexport const BACKUPS_DIRECTORY = `${KITE3D_DIRECTORY}/backups`\nexport const RUNNING_DIRECTORY = `${KITE3D_DIRECTORY}/running`\nexport const KITE3D_SERVER_CLIENT_ID = 'kite3d-server'\n"],"names":["KITE3D_DIRECTORY","DEPLOYS_PATH","JOURNAL_PATH","STATE_PATH","CONSOLE_PATH","THUMBS_DIRECTORY","BACKUPS_DIRECTORY","RUNNING_DIRECTORY","KITE3D_SERVER_CLIENT_ID"],"mappings":"AAAO,MAAMA,IAAmB,WACnBC,IAAe,GAAGD,CAAgB,iBAClCE,IAAe,GAAGF,CAAgB,kBAClCG,IAAa,GAAGH,CAAgB,eAChCI,IAAe,GAAGJ,CAAgB,gBAClCK,IAAmB,GAAGL,CAAgB,WACtCM,IAAoB,GAAGN,CAAgB,YACvCO,IAAoB,GAAGP,CAAgB,YACvCQ,IAA0B;"}

package/dist/plugins/GeneratorComponent.d.ts

@@ -0,0 +1,40 @@
+import { ComponentDefn, IObject3D, Object3DComponent, ThreeViewer } from 'threepipe';
+export interface GeneratorParams {
+    [key: string]: unknown;
+}
+export interface GeneratorContext {
+    node: IObject3D;
+    params: GeneratorParams;
+    viewer: ThreeViewer;
+    engine: Record<string, unknown>;
+}
+export interface GeneratorModule {
+    default?: (context: GeneratorContext) => unknown | Promise<unknown>;
+}
+export interface GeneratorViewerOptions {
+    base: string | URL;
+    onError?: (error: unknown) => void;
+}
+export declare class GeneratorComponent extends Object3DComponent {
+    static ComponentType: string;
+    static StateProperties: ComponentDefn['StateProperties'];
+    module: string;
+    params: GeneratorParams;
+    private runRevision;
+    static configureViewer(viewer: ThreeViewer, options: GeneratorViewerOptions): void;
+    static waitForViewer(viewer: ThreeViewer): Promise<void>;
+    init(object: IObject3D, state: Record<string, unknown>): void;
+    run(): Promise<void>;
+    bake(): Promise<number>;
+    destroy(): Record<string, unknown>;
+}
+export interface RunGeneratorOptions extends Omit<GeneratorContext, 'engine'> {
+    module: string;
+    base: URL;
+    revision?: number;
+    isCurrent?: () => boolean;
+}
+export declare function runGenerator({ node, params, viewer, module, base, revision, isCurrent, }: RunGeneratorOptions): Promise<IObject3D[]>;
+export declare function removeGeneratedChildren(node: IObject3D): void;
+export declare function markGenerated(object: IObject3D, sourceId?: string, outputIndex?: number): void;
+export declare function resolveGeneratorModule(module: string, base: URL): URL;

package/dist/plugins/HtmlUiComponent.d.ts

@@ -0,0 +1,52 @@
+import { ComponentDefn, ComponentJSON, IObject3D, Object3DComponent, ViewerEventMap } from 'threepipe';
+export declare const uiPositionMode: readonly ["world", "screen", "viewport"];
+export type UiPositionMode = typeof uiPositionMode[number];
+export declare class HtmlUiComponent extends Object3DComponent {
+    static ComponentType: string;
+    static StateProperties: ComponentDefn['StateProperties'];
+    element: HTMLDivElement;
+    enabled: boolean;
+    htmlData: string;
+    width: number;
+    height: number;
+    scrollable: boolean;
+    interactable: boolean;
+    visible: boolean;
+    appendToBody: boolean;
+    positionMode: UiPositionMode;
+    offsetX: number;
+    offsetY: number;
+    zIndex: number;
+    private _worldPosition;
+    private _animationFrameId?;
+    constructor();
+    private _objectUpdate;
+    init(object: IObject3D, state: ComponentJSON['state']): void;
+    destroy(): Record<string, any>;
+    private _stopPositionTracking;
+    preFrame({ resized }: ViewerEventMap["preFrame"]): boolean | void;
+    private _updateElementPosition;
+    private _updateWorldPosition;
+    private _updateScreenPosition;
+    private _updateViewportPosition;
+    /**
+     * Update the HTML content programmatically
+     */
+    setHtml(html: string): void;
+    /**
+     * Set the position
+     */
+    setPosition(x: number, y: number): void;
+    /**
+     * Set the size
+     */
+    setSize(width: number, height: number): void;
+    /**
+     * Show the element
+     */
+    show(): void;
+    /**
+     * Hide the element
+     */
+    hide(): void;
+}

package/dist/plugins/cannon/Cannon3DBodyComponent.d.ts

@@ -0,0 +1,27 @@
+import { Body } from 'cannon-es';
+import { ComponentDefn, ComponentJSON, IObject3D, Object3DComponent } from 'threepipe';
+import { Cannon3DShapeComponent } from './Cannon3DShapeComponent.ts';
+import { CannonMaterial2 } from './CannonPhysicsPlugin.ts';
+export declare const physicsBodyType: readonly ["static", "dynamic", "kinematic"];
+export type PhysicsBodyType = typeof physicsBodyType[number];
+export declare class Cannon3DBodyComponent extends Object3DComponent {
+    static ComponentType: string;
+    static StateProperties: ComponentDefn['StateProperties'];
+    body: Body;
+    mass: number;
+    type: PhysicsBodyType;
+    isTrigger: boolean;
+    material: CannonMaterial2;
+    private _typeToCannon;
+    updateMassProperties(): void;
+    updateBoundingRadius(): void;
+    constructor();
+    private _objectUpdate;
+    init(object: IObject3D, state: ComponentJSON['state']): void;
+    destroy(): Record<string, any>;
+    resetTransform(changeKey?: string): void;
+    shapeRefs: Cannon3DShapeComponent[];
+    addShape(shape: Cannon3DShapeComponent, refresh?: boolean): void;
+    removeShape(shape: Cannon3DShapeComponent, refresh?: boolean): void;
+    refreshShapes(update?: boolean): void;
+}

package/dist/plugins/cannon/Cannon3DShapeComponent.d.ts

@@ -0,0 +1,57 @@
+import { AHelperWidget, ComponentDefn, ComponentJSON, IObject3D, Object3DComponent, PartialRecord } from 'threepipe';
+import { ShapeParameters, ShapeResult, ShapeType } from './threeToCannon';
+import { Cannon3DBodyComponent } from './Cannon3DBodyComponent.ts';
+export declare const typeToCannon: {
+    readonly autoBox: ShapeType.BOX;
+    readonly autoCylinder: ShapeType.CYLINDER;
+    readonly autoSphere: ShapeType.SPHERE;
+    readonly autoConvex: ShapeType.HULL;
+    readonly autoTrimesh: ShapeType.MESH;
+    readonly box: ShapeType.BOX;
+    readonly sphere: ShapeType.SPHERE;
+    readonly cylinder: ShapeType.CYLINDER;
+    readonly convex: ShapeType.HULL;
+    readonly trimesh: ShapeType.MESH;
+};
+export type CannonShapeType = keyof typeof typeToCannon;
+export declare const cannonShapeTypes: CannonShapeType[];
+export declare const cannonShapeTypeParams: PartialRecord<CannonShapeType, ShapeParameters['params']>;
+export declare class Cannon3DShapeComponent extends Object3DComponent {
+    static ComponentType: string;
+    static StateProperties: ComponentDefn['StateProperties'];
+    static EmptyResult: ShapeResult;
+    result: ShapeResult;
+    bodyRef: Cannon3DBodyComponent | undefined;
+    type: CannonShapeType;
+    params: ShapeParameters | null;
+    constructor();
+    init(object: IObject3D, state: ComponentJSON['state']): void;
+    destroy(): Record<string, any>;
+    refreshShape(refreshBody?: boolean): void;
+    private _needsUpdate;
+    objectUpdate: (e: any) => void;
+    childadded: (e: any) => void;
+    childremoved: (e: any) => void;
+    preFrame: () => void;
+}
+export declare class Cannon3DShapeHelper extends AHelperWidget {
+    autoUpgradeChildren: boolean;
+    private _shapes;
+    private _meshes;
+    object: IObject3D | undefined;
+    private _gp;
+    constructor(object: IObject3D);
+    update(): void;
+    dispose(): void;
+    static Check(obj: IObject3D): boolean;
+    static Create(obj: IObject3D): Cannon3DShapeHelper;
+}
+declare module 'threepipe' {
+    interface IObject3D {
+        /**
+         * Shapes associated with this object
+         * @internal - for cannon js physics
+         */
+        ['__cannonShapes']?: ShapeResult[];
+    }
+}

package/dist/plugins/cannon/CannonPhysicsPlugin.d.ts

@@ -0,0 +1,63 @@
+import { Body, ContactMaterial, Material as CannonMaterial, Shape, World } from 'cannon-es';
+import { AViewerPluginSync, EntityComponentPlugin, IObject3D, IViewerEvent, ThreeViewer } from 'threepipe';
+import { Cannon3DShapeComponent } from './Cannon3DShapeComponent.ts';
+import { Cannon3DBodyComponent } from './Cannon3DBodyComponent.ts';
+import { CannonRagdollComponent } from './CannonRagdollComponent.ts';
+export declare class CannonMaterial2 extends CannonMaterial {
+    name: string;
+    uuid: string;
+    friction: number;
+    restitution: number;
+}
+export declare class CannonPhysicsPlugin extends AViewerPluginSync {
+    static readonly PluginType = "CannonPhysicsPlugin";
+    private _world;
+    get world(): World;
+    enabled: boolean;
+    static CannonTypes: {
+        Body: typeof Body;
+        Shape: typeof Shape;
+        World: typeof World;
+        Material: typeof CannonMaterial;
+        ContactMaterial: typeof ContactMaterial;
+    };
+    running: boolean;
+    nextSteps: number;
+    stepPhysics: any;
+    defaultMaterial: CannonMaterial2;
+    constructor(enabled?: boolean, running?: boolean);
+    dependencies: (typeof EntityComponentPlugin)[];
+    private _v1;
+    private _v2;
+    private _s2;
+    private _q1;
+    private _q2;
+    private _m1;
+    private _m2;
+    frameFadeToggled: boolean;
+    protected _preFrame: (e: IViewerEvent) => void;
+    private _onRemove;
+    onAdded(viewer: ThreeViewer): Promise<void>;
+    private _objectAdd;
+    private _objectRemove;
+    onRemove(viewer: ThreeViewer): void;
+    readonly componentTypes: {
+        body: typeof Cannon3DBodyComponent;
+        shape: typeof Cannon3DShapeComponent;
+        ragdoll: typeof CannonRagdollComponent;
+    };
+    bodyComponents: Set<Cannon3DBodyComponent>;
+    cannonBodies: WeakMap<Body, Cannon3DBodyComponent>;
+    addBody(body: Cannon3DBodyComponent): void;
+    removeBody(body: Cannon3DBodyComponent): void;
+}
+export interface CollisionEvent {
+    object: IObject3D;
+    body: Cannon3DBodyComponent;
+}
+declare module 'threepipe' {
+    interface Object3DComponent {
+        onBeginContact?(collisionEvent: any): void;
+        onEndContact?(collisionEvent: any): void;
+    }
+}

package/dist/plugins/cannon/CannonRagdollComponent.d.ts

@@ -0,0 +1,148 @@
+import { Body, ConeTwistConstraint, Constraint, Vec3 } from 'cannon-es';
+import { ComponentDefn, ComponentJSON, IObject3D, Object3DComponent, ViewerEventMap } from 'threepipe';
+import { CannonMaterial2 } from './CannonPhysicsPlugin.ts';
+export interface RagdollConfig {
+    scale: number;
+    angle: number;
+    angleShoulders: number;
+    twistAngle: number;
+}
+export interface RagdollParts {
+    lowerLeftLeg: Body;
+    lowerRightLeg: Body;
+    upperLeftLeg: Body;
+    upperRightLeg: Body;
+    pelvis: Body;
+    upperBody: Body;
+    head: Body;
+    upperLeftArm: Body;
+    upperRightArm: Body;
+    lowerLeftArm: Body;
+    lowerRightArm: Body;
+}
+export interface RagdollConstraints {
+    neckJoint: ConeTwistConstraint;
+    leftKneeJoint: ConeTwistConstraint;
+    rightKneeJoint: ConeTwistConstraint;
+    leftHipJoint: ConeTwistConstraint;
+    rightHipJoint: ConeTwistConstraint;
+    spineJoint: ConeTwistConstraint;
+    leftShoulder: ConeTwistConstraint;
+    rightShoulder: ConeTwistConstraint;
+    leftElbowJoint: ConeTwistConstraint;
+    rightElbowJoint: ConeTwistConstraint;
+}
+export declare class CannonRagdollComponent extends Object3DComponent {
+    static ComponentType: string;
+    static StateProperties: ComponentDefn['StateProperties'];
+    scale: number;
+    angle: number;
+    angleShoulders: number;
+    twistAngle: number;
+    mass: number;
+    /** If true, creates ragdoll bodies on init. If false, waits for activate() call */
+    autoCreateOnInit: boolean;
+    /** If true, hides the debug ragdoll meshes (useful when using with character model) */
+    hideRagdollMeshes: boolean;
+    material: CannonMaterial2;
+    private _bodies;
+    private _constraints;
+    private _parts;
+    private _ragdollConstraints;
+    private _cannon;
+    private _meshes;
+    private _meshContainer;
+    private _visualMaterial;
+    private _lastObjectPosition;
+    private _lastObjectQuaternion;
+    private _initialized;
+    private _isActive;
+    private _characterMeshes;
+    private _boneMap;
+    private _initialBoneQuats;
+    private _initialBoneWorldQuats;
+    private _initialBodyQuats;
+    private _boneNames;
+    private _currentObjectPosition;
+    private _currentObjectQuaternion;
+    private _deltaQuaternion;
+    private _invLastQuaternion;
+    private _tempVec3;
+    private _pivotPoint;
+    private _tempWorldPos;
+    private _tempWorldQuat;
+    get bodies(): Body[];
+    get constraints(): Constraint[];
+    get parts(): RagdollParts | null;
+    get ragdollConstraints(): RagdollConstraints | null;
+    /** Returns true if ragdoll physics is currently active */
+    get isActive(): boolean;
+    constructor();
+    init(object: IObject3D, state: ComponentJSON['state']): void;
+    destroy(): Record<string, any>;
+    preFrame(_event: ViewerEventMap["preFrame"]): void;
+    /**
+     * Syncs the character's bones to match the ragdoll body positions/rotations.
+     * Called each frame when ragdoll is active.
+     *
+     * The approach:
+     * 1. Calculate how much the ragdoll body has rotated in world space (delta from initial)
+     * 2. Apply that same world-space delta to the bone's initial world orientation
+     * 3. Convert the new world orientation back to local space for the bone
+     *
+     * Note: Only the root bone (hips) gets position updates. Other bones only get rotation updates
+     * because in a skeleton hierarchy, bone positions are fixed (defined by bone length).
+     */
+    private _syncRagdollToBones;
+    private _syncObjectPosition;
+    private _updateMeshes;
+    private _recreateRagdoll;
+    private _updateMass;
+    private _updateConstraints;
+    private _createRagdoll;
+    private _removeRagdoll;
+    /**
+     * Reset the ragdoll to its initial position relative to the object
+     */
+    resetPosition(): void;
+    /**
+     * Apply an impulse to all bodies
+     */
+    applyImpulse(impulse: Vec3, worldPoint?: Vec3): void;
+    /**
+     * Apply an impulse to a specific body part
+     */
+    applyImpulseToPart(partName: keyof RagdollParts, impulse: Vec3, worldPoint?: Vec3): void;
+    private _updateMeshVisibility;
+    private _findCharacterMeshes;
+    private _buildBoneMap;
+    private _findBone;
+    private _getBoneWorldPosition;
+    private _getBoneWorldQuaternion;
+    start(): void;
+    /**
+     * Activates the ragdoll physics simulation.
+     * Call this when the character should start ragdolling (e.g., on death).
+     * @param impulse Optional initial impulse to apply (e.g., from bullet impact)
+     * @param impactPoint Optional world point where impulse is applied
+     */
+    activate(impulse?: Vec3, impactPoint?: Vec3): void;
+    /**
+     * Store initial bone quaternions (both local and world space) for rotation offset calculation
+     */
+    private _storeInitialBoneQuats;
+    /**
+     * Store initial body quaternions (world space) for rotation offset calculation
+     */
+    private _storeInitialBodyQuats;
+    /**
+     * Deactivates the ragdoll and restores the character.
+     * Call this to reset the character to normal state.
+     */
+    deactivate(): void;
+    private _matchBonesToRagdoll;
+    private _activateBodies;
+    private _deactivateBodies;
+    private _setCharacterVisible;
+    private _findClosestBody;
+}

package/dist/plugins/cannon/helper.d.ts

@@ -0,0 +1,24 @@
+import { ConvexPolyhedron, Heightfield, Shape, Trimesh } from 'cannon-es';
+import { BufferGeometry, Mesh } from 'threepipe';
+type ComplexShape = Shape & {
+    geometryId?: number;
+};
+export declare function cannonDebugger(): {
+    createConvexPolyhedronGeometry: (shape: ConvexPolyhedron) => BufferGeometry;
+    createTrimeshGeometry: (shape: Trimesh) => BufferGeometry;
+    createHeightfieldGeometry: (shape: Heightfield) => BufferGeometry;
+    createMesh: (shape: Shape) => Mesh;
+    scaleMesh: (mesh: Mesh, shape: Shape | ComplexShape) => void;
+    typeMatch: (mesh: Mesh | undefined, shape: Shape | ComplexShape) => boolean;
+    updateMesh: (mesh: Mesh | undefined, shape: Shape | ComplexShape) => Mesh<BufferGeometry<import('three').NormalBufferAttributes, import('three').BufferGeometryEventMap>, import('three').Material<import('three').MaterialEventMap> | import('three').Material<import('three').MaterialEventMap>[], import('three').Object3DEventMap> | undefined;
+};
+export declare const CannonDebugger: {
+    createConvexPolyhedronGeometry: (shape: ConvexPolyhedron) => BufferGeometry;
+    createTrimeshGeometry: (shape: Trimesh) => BufferGeometry;
+    createHeightfieldGeometry: (shape: Heightfield) => BufferGeometry;
+    createMesh: (shape: Shape) => Mesh;
+    scaleMesh: (mesh: Mesh, shape: Shape | ComplexShape) => void;
+    typeMatch: (mesh: Mesh | undefined, shape: Shape | ComplexShape) => boolean;
+    updateMesh: (mesh: Mesh | undefined, shape: Shape | ComplexShape) => Mesh<BufferGeometry<import('three').NormalBufferAttributes, import('three').BufferGeometryEventMap>, import('three').Material<import('three').MaterialEventMap> | import('three').Material<import('three').MaterialEventMap>[], import('three').Object3DEventMap> | undefined;
+};
+export {};

package/dist/plugins/cannon/threeToCannon.d.ts

@@ -0,0 +1,63 @@
+import { Quaternion as CQuaternion, Shape, Vec3 } from 'cannon-es';
+import { Object3D } from 'threepipe';
+export type BoxParameters = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type CylinderParameters = {
+    radiusTop: number;
+    radiusBottom: number;
+    height: number;
+    segments: number;
+};
+export type SphereParameters = {
+    radius: number;
+};
+export type ConvexPolyhedronParameters = {
+    vertices: Float32Array;
+    faces: number[][];
+};
+export type TrimeshParameters = {
+    vertices: Float32Array;
+    indices: Uint32Array;
+};
+type ShapeTypeToShapeParameters = {
+    Box: BoxParameters;
+    Cylinder: CylinderParameters;
+    Sphere: SphereParameters;
+    ConvexPolyhedron: ConvexPolyhedronParameters;
+    Trimesh: TrimeshParameters;
+};
+export declare enum ShapeType {
+    BOX = "Box",
+    CYLINDER = "Cylinder",
+    SPHERE = "Sphere",
+    HULL = "ConvexPolyhedron",
+    MESH = "Trimesh"
+}
+export interface ShapeOptions {
+    type?: ShapeType;
+    cylinderAxis?: 'x' | 'y' | 'z';
+    sphereRadius?: number;
+}
+export interface ShapeParameters<T extends ShapeType = ShapeType> {
+    type: T;
+    params: ShapeTypeToShapeParameters[T];
+    offset?: Vec3;
+    orientation?: CQuaternion;
+}
+export interface ShapeResult<T extends Shape = Shape> {
+    shape: T;
+    offset?: Vec3;
+    orientation?: CQuaternion;
+}
+/**
+ * Given a THREE.Object3D instance, creates parameters for a CANNON shape.
+ */
+export declare const getShapeParameters: (object: Object3D, options?: ShapeOptions) => ShapeParameters | null;
+/**
+ * Given a THREE.Object3D instance, creates a corresponding CANNON shape.
+ */
+export declare const threeToCannon: (object: Object3D, options?: ShapeOptions, shapeParameters?: ShapeParameters | null) => ShapeResult | null;
+export {};

package/dist/plugins/cannon/utils.d.ts

@@ -0,0 +1,9 @@
+import { BufferGeometry, Object3D, Vector3 } from 'threepipe';
+/**
+ * Returns a single geometry for the given object. If the object is compound,
+ * its geometries are automatically merged. Bake world scale into each
+ * geometry, because we can't easily apply that to the cannonjs shapes later.
+ */
+export declare function getGeometry(object: Object3D): BufferGeometry | null;
+export declare function getVertices(geometry: BufferGeometry): Float32Array;
+export declare function getComponent(v: Vector3, component: string): number;

package/dist/projectFormat.js

@@ -0,0 +1,108 @@
+import { parse as w } from "jsonc-parser";
+const b = "kite3d", S = `/${b}/`;
+function v(t, e) {
+  const n = e.dependencies;
+  return g(n) && Object.prototype.hasOwnProperty.call(n, t);
+}
+function O(t) {
+  const e = w(t);
+  if (!e || typeof e != "object" || Array.isArray(e))
+    throw new Error("Invalid package.json file: expected an object");
+  const n = e;
+  if (typeof n.mainScene != "string" || !n.mainScene.toLowerCase().endsWith(".gltf"))
+    throw new Error("package.json mainScene must name a text .gltf file");
+  return n;
+}
+function x(t) {
+  const e = w(t);
+  if (e.files && typeof e.files != "object")
+    throw new Error("Invalid assets.json file: files should be an object");
+  if (e.version !== void 0 && typeof e.version != "number")
+    throw new Error("Invalid assets.json file: version should be a number");
+  return e.files || (e.files = {}), e.version || (e.version = 1), e;
+}
+function N(t, e) {
+  const n = JSON.parse(e);
+  if (!n || typeof n != "object" || !n.asset)
+    throw new Error(`${t} is not a JSON glTF document`);
+}
+function k(t) {
+  var e;
+  try {
+    const n = JSON.parse(t), i = [];
+    for (const [c, a] of (n.nodes || []).entries())
+      for (const [p, o] of Object.entries(((e = a.extras) == null ? void 0 : e.EntityComponentPlugin) || {}))
+        o.type !== "Generator" || !g(o.state) || i.push({
+          componentId: p,
+          module: typeof o.state.module == "string" ? o.state.module : "",
+          nodeIndex: c,
+          nodeName: typeof a.name == "string" ? a.name : `Node ${c}`,
+          params: g(o.state.params) ? o.state.params : {}
+        });
+    return i;
+  } catch {
+    return [];
+  }
+}
+function A(t, e, n) {
+  var a, p, o, f, d;
+  const i = JSON.parse(t), c = (d = (f = (o = (p = (a = i.nodes) == null ? void 0 : a[e.nodeIndex]) == null ? void 0 : p.extras) == null ? void 0 : o.EntityComponentPlugin) == null ? void 0 : f[e.componentId]) == null ? void 0 : d.state;
+  if (!g(c)) throw new Error(`Generator component is missing on ${e.nodeName}`);
+  return Object.assign(c, n), { text: JSON.stringify(i, null, 2), state: c };
+}
+async function E(t, e) {
+  var f, d;
+  const n = t[b] ?? {}, i = [], a = {
+    ...t.dependencies && typeof t.dependencies == "object" && !Array.isArray(t.dependencies) ? t.dependencies : {}
+  };
+  i.push(...Object.entries(a).map(([s, r]) => ({ key: s, version: r }))), n.imports && i.push(...Object.entries(n.imports).map(([s, r]) => ({
+    key: s,
+    url: r.startsWith("@") ? void 0 : r,
+    version: r.startsWith("@") ? r.slice(1) : ""
+  })));
+  const p = ((f = n.plugins) == null ? void 0 : f.map((s) => {
+    if (typeof s != "string") return s;
+    const r = s.match(/\((.*)\)$/);
+    let y, l = s;
+    if (r) {
+      const h = r[1].trim();
+      if (l = s.slice(0, r.index).trim(), h)
+        try {
+          const m = [];
+          if (y = w(`[${h}]`, m), !Array.isArray(y) || m.length)
+            throw console.error(m), new Error("Plugin params is not a valid array");
+        } catch (m) {
+          return console.error("Unable to parse plugin params, skipping plugin", s, h, m), null;
+        }
+    }
+    const u = l.lastIndexOf(":");
+    return {
+      import: u !== -1 ? l.slice(0, u) : l,
+      className: u !== -1 ? l.slice(u + 1) : void 0,
+      params: y
+    };
+  })) || [], o = ((d = n.scripts) == null ? void 0 : d.map(
+    (s) => typeof s == "string" ? { import: s } : s
+  )) || [];
+  return {
+    plugins: p.filter(Boolean),
+    scripts: o,
+    dependencies: i,
+    viewer: n.viewer || {}
+  };
+}
+function g(t) {
+  return !!t && typeof t == "object" && !Array.isArray(t);
+}
+export {
+  S as assetUrlPrefix,
+  v as isDependencyModuleSpecifier,
+  x as parseAssetsJSONManifest,
+  O as parsePackageJSON,
+  E as parsePackageJsonSettingsConfig,
+  k as readProjectGeneratorStates,
+  b as settingsKey,
+  A as updateProjectGeneratorState,
+  N as validateSceneSource
+};
+//# sourceMappingURL=projectFormat.js.map