@vvfx/ge-ir 0.0.1-beat.2

package/dist/ir2ge/assembly/generator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Unified IR → GE scene generation pipeline. All IR sources (lottie, dsl2ge,
+ * future) are processed here. Source-specific features are gated by data
+ * existence (e.g. mask, precomp, shape layers are absent in dsl IR and
+ * naturally skipped); `ir.source` branches are used only for B-class real
+ * semantic differences that cannot be expressed via data existence.
+ */
+import type { IRComposition } from '@vvfx/animation-ir';
+import type { JSONScene } from '@galacean/effects-specification';
+/**
+ * Convert an IR composition to a GE JSONScene.
+ *
+ * All IR sources (lottie, dsl2ge, future) go through this single unified
+ * pipeline. Source-specific features are gated by data existence (e.g. mask,
+ * precomp, shape layers are absent in dsl IR and naturally skipped);
+ * `ir.source` branches are used only for B-class real semantic differences
+ * that cannot be expressed via data existence.
+ *
+ * The optional `duration` arg is a caller override; lottie2ge currently passes
+ * the duration computed from the raw json upstream. When omitted, the
+ * canonical assembler derives it from `(outPoint - inPoint) / frameRate`.
+ */
+export declare function convertIRToGE(ir: IRComposition, duration?: number): JSONScene;

package/dist/ir2ge/assembly/scene-assembly.d.ts

@@ -0,0 +1,11 @@
+import { type IRComposition } from '@vvfx/animation-ir';
+import { type JSONScene } from '@galacean/effects-specification';
+import type { ECSCollector, ProcessedItem } from '../types';
+/**
+ * Assemble the top-level GE JSONScene wrapper from a populated collector.
+ *
+ * Reads composition-level properties (`name`, `width`/`height`, `endBehavior`,
+ * `backgroundColor`) directly from the IR. The optional `duration` arg is a
+ * caller override — when omitted, derived from `(outPoint - inPoint) / frameRate`.
+ */
+export declare function assembleScene(ir: IRComposition, collector: ECSCollector, processedItems: ProcessedItem[], duration?: number): JSONScene;

package/dist/ir2ge/builders/animation.d.ts

@@ -0,0 +1,4 @@
+import type { IRComposition, IRLayerNode } from '@vvfx/animation-ir';
+import type { LayerProcessingContext, TransformAnimation } from '../types';
+export declare function buildTransformAnimation(layer: IRLayerNode, ctx: LayerProcessingContext): TransformAnimation;
+export declare function buildColorAnimation(layer: IRLayerNode, ir: IRComposition): Record<string, unknown> | undefined;

package/dist/ir2ge/builders/bezier.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Converts IR keyframe-based animation data to GE BezierKeyframeValue format.
+ *
+ * GE BezierKeyframeValue format per keyframe:
+ * - First:  [EASE_OUT(3), [t, v, out_cp_x, out_cp_y]]
+ * - Middle: [EASE(1),     [in_cp_x, in_cp_y, t, v, out_cp_x, out_cp_y]]
+ * - Last:   [EASE_IN(2),  [in_cp_x, in_cp_y, t, v]]
+ *
+ * Time is normalized to [0, 1] based on the layer's visible frame range (ip → op).
+ */
+import type { IRAnimatedProperty, IRVec3 } from '@vvfx/animation-ir';
+import { type BezierKeyframeValue } from '@galacean/effects-specification';
+export interface IRToGETimeContext {
+    /** Layer visible start frame. */
+    startFrame: number;
+    /** Layer visible end frame. */
+    endFrame: number;
+}
+export interface IRPositionGEResult {
+    /** Timing curves in BezierKeyframeValue format (1D, time-domain only). */
+    curves: BezierKeyframeValue[][];
+    /** Path points per segment: [[start_x, start_y], [end_x, end_y]]. */
+    pathPoints: [[number, number], [number, number]][];
+    /** Spatial control points per segment: [[to_x, to_y], [ti_x, ti_y]]. */
+    controlPoints: [[number, number], [number, number]][];
+}
+/**
+ * Convert a 1D animated property (opacity / rotation) to GE BezierKeyframeValue[][].
+ * Returns a single-element outer array with the full curve.
+ */
+export declare function irScalarKeyframesToGE(property: IRAnimatedProperty<number>, timeContext: IRToGETimeContext): BezierKeyframeValue[][] | undefined;
+/**
+ * Convert a multi-dimensional animated property (scale / anchor) to GE BezierKeyframeValue[][].
+ * Returns one curve per dimension in the outer array.
+ */
+export declare function irVectorKeyframesToGE(property: IRAnimatedProperty<IRVec3>, timeContext: IRToGETimeContext): BezierKeyframeValue[][] | undefined;
+/**
+ * Convert position keyframes to GE path animation format (pp/cp + timing curves).
+ */
+export declare function irPositionKeyframesToGE(property: IRAnimatedProperty<IRVec3>, timeContext: IRToGETimeContext): IRPositionGEResult | undefined;
+/**
+ * Determine if a property has enough keyframes to warrant keyframe mode (pkf/skf/rkf/okf).
+ */
+export declare function shouldUseKeyframeMode(property: IRAnimatedProperty): boolean;

package/dist/ir2ge/builders/component.d.ts

@@ -0,0 +1,13 @@
+import type { IRComposition, IRLayerNode, IRShapeData } from '@vvfx/animation-ir';
+import type { LayerProcessingContext } from '../types';
+export declare function buildComponent(layer: IRLayerNode, itemId: string, anchorScaleX: number, anchorScaleY: number, ctx: LayerProcessingContext): string | undefined;
+/**
+ * Copy the raw GE mask object (from ge2ir passthrough metadata) onto a freshly
+ * built component, as a top-level `mask` field matching GE's structure. For a
+ * mask SOURCE this carries `{isMask:true, alphaMaskEnabled}`; for a TARGET it
+ * carries `{isMask:false, reference, inverted}` where `reference.id` is still
+ * the stale GE1 component id — `applyGeMaskRemap` rewrites it in post-process.
+ * No-op for non-ge sources (Lottie masks go through the IRLayerNode.mask path).
+ */
+export declare function applyGeMask(ir: IRComposition, layer: IRLayerNode, component: Record<string, unknown>): void;
+export declare function buildShapeOptions(shapeData: IRShapeData, ratio: number, ctx?: LayerProcessingContext): Record<string, unknown>;

package/dist/ir2ge/builders/effects.d.ts

@@ -0,0 +1,9 @@
+import { type IRBlendMode } from '@vvfx/animation-ir';
+import type { DataPath } from '@galacean/effects-specification';
+import type { ECSCollector, GETransform } from '../types';
+export { estimateTextWidth } from '../utils';
+export declare function buildGETransform(position: [number, number, number], eulerHint: [number, number, number], scale: [number, number, number]): GETransform;
+export declare function getGEItemType(type: string): string;
+export declare function getGEItemTypeCode(type: string): string;
+export declare function registerTexture(collector: ECSCollector, imageUrl: string, cache: Map<string, DataPath>): DataPath;
+export declare function mapBlendingMode(blendMode: IRBlendMode | undefined): number | undefined;

package/dist/ir2ge/builders/layer.d.ts

@@ -0,0 +1,5 @@
+import type { IRLayerNode } from '@vvfx/animation-ir';
+import type { LayerProcessingContext } from '../types';
+export declare function processNullLayer(layer: IRLayerNode, ctx: LayerProcessingContext): void;
+export declare function processParentLayer(layer: IRLayerNode, ctx: LayerProcessingContext): void;
+export declare function processVisualLayer(layer: IRLayerNode, ctx: LayerProcessingContext): void;

package/dist/ir2ge/builders/timeline.d.ts

@@ -0,0 +1,9 @@
+import type { ECSCollector, TransformAnimation } from '../types';
+/**
+ * Build the ObjectBindingTrack + Activation/Transform/SpriteColor child tracks
+ * for one VFX item. Shared by lottie2ge and dsl2ge generators.
+ *
+ * The SpriteColor track is omitted for null layers (itemType `'null'` or
+ * the GE numeric code `'3'`).
+ */
+export declare function buildTimelineTracks(collector: ECSCollector, delay: number, duration: number, endBehavior: number, animation: TransformAnimation, itemType: string): string;

package/dist/ir2ge/builders/timing.d.ts

@@ -0,0 +1,17 @@
+import type { IRLayerNode } from '@vvfx/animation-ir';
+/**
+ * Map an IR layer's time range to GE delay/duration in seconds, applying
+ * the time-stretch and offset semantics from `IRTimeContext`.
+ *
+ * dsl-source IRs leave `stretch` and `offsetFrame` undefined, in which case
+ * this collapses to `delay = startFrame / fr` and
+ * `duration = (endFrame - startFrame) / fr` — exactly what dsl2ge used to
+ * compute inline.
+ *
+ * Zero/negative durations are clamped to a 0.0001 epsilon so GE keeps the
+ * activation track alive for the (degenerate) layer.
+ */
+export declare function computeLayerTiming(layer: IRLayerNode, frameRate: number): {
+    delay: number;
+    layerDuration: number;
+};

package/dist/ir2ge/index.d.ts

@@ -0,0 +1,14 @@
+export { convertIRToGE } from './assembly/generator';
+export type { DataPath, JSONScene } from '@galacean/effects-specification';
+export { readLottieSpecific } from './ir/specific';
+export type { LottieLayerSpecific } from './ir/specific';
+export { isTransformOnlyParentLink } from './ir/parent-link';
+export type { ECSCollector, GEDataPath, GEItem, GEPoolIndex, GERecord, GETransform } from '../shared/types';
+export type { ProcessedItem, TransformAnimation } from './types';
+export { assembleScene } from './assembly/scene-assembly';
+export { estimateTextWidth, roundNumber, lerp, createId, toDataPath } from './utils';
+export { DEFAULT_CLIP_MODE, DEFAULT_CAMERA_FOV, DEFAULT_CAMERA_Z, get2dTo3dRatio, convert2dTo3dPoint, } from '../shared/coordinate';
+export { irScalarKeyframesToGE, irVectorKeyframesToGE, irPositionKeyframesToGE, shouldUseKeyframeMode, } from './builders/bezier';
+export type { IRToGETimeContext, IRPositionGEResult } from './builders/bezier';
+export { buildTimelineTracks } from './builders/timeline';
+export { normalizeChildVisibilityByParentDelays } from './post-process/visibility';

package/dist/ir2ge/ir/anchor-strategy.d.ts

@@ -0,0 +1,24 @@
+import type { IRComposition, IRLayerNode } from '@vvfx/animation-ir';
+/**
+ * How the generator should handle a layer's anchor offset.
+ *
+ * - `inline-anchor` — emit one VFX item with `renderer.anchor` baked into the
+ *   GE renderer and `anchorOffset` shifted into `transform.position`. Centered
+ *   layers also use this kind with `anchorScale = [0.5, 0.5]` and
+ *   `anchorOffset = [0, 0]`.
+ * - `split-null-sprite` — emit a null+sprite hierarchy so the transform pivot
+ *   sits at the anchor; the sprite carries the visual content and is parented
+ *   to the null with an anchor-relative position.
+ *
+ * The split decision is read from `IRLayerNode.transformSplit` when set by the
+ * producer; for lottie IR without that flag the accessor falls back to
+ * runtime geometry checks (rotation/scale animation + off-center anchor).
+ */
+export type AnchorStrategy = {
+    kind: 'inline-anchor';
+    anchorScale: [number, number];
+    anchorOffset: [number, number];
+} | {
+    kind: 'split-null-sprite';
+};
+export declare function getStaticAnchorBehavior(ir: IRComposition, layer: IRLayerNode): AnchorStrategy;

package/dist/ir2ge/ir/layer-dimensions.d.ts

@@ -0,0 +1,13 @@
+import type { IRLayerNode } from '@vvfx/animation-ir';
+/**
+ * Read the producer-baked display size from an IR layer. When the producer
+ * did not resolve one, returns `fallback` (defaults to `{ 1, 1 }` — the
+ * value every existing call site was using inline).
+ */
+export declare function getLayerDisplaySize(layer: IRLayerNode, fallback?: {
+    width: number;
+    height: number;
+}): {
+    width: number;
+    height: number;
+};

package/dist/ir2ge/ir/layer-utils.d.ts

@@ -0,0 +1,14 @@
+import type { IRLayerNode } from '@vvfx/animation-ir';
+import type { IRToGETimeContext } from '../builders/bezier';
+import type { LayerProcessingContext } from '../types';
+export { computeLayerTiming } from '../builders/timing';
+export declare function computeStaticPosition(layer: IRLayerNode, ctx: LayerProcessingContext, anchorOffsetX?: number, anchorOffsetY?: number): [number, number, number];
+export declare function getStaticAnchor(layer: IRLayerNode): [number, number];
+export declare function applyScalePositionAdjust(position: [number, number, number], layer: IRLayerNode, layerWidth: number, layerHeight: number, ratio: number): [number, number, number];
+export declare function computeAnchorInfo(layer: IRLayerNode, layerWidth: number, layerHeight: number): {
+    anchorScaleX: number;
+    anchorScaleY: number;
+    anchorOffsetX: number;
+    anchorOffsetY: number;
+};
+export declare function getTimeContext(layer: IRLayerNode): IRToGETimeContext;

package/dist/ir2ge/ir/parent-link.d.ts

@@ -0,0 +1,15 @@
+import type { IRLayerNode } from '@vvfx/animation-ir';
+/**
+ * True when the layer's parent only inherits transform — visibility and
+ * lifetime are independent of the parent's window.
+ *
+ * Reads `IRLayerReference.linkKind` directly. Producers that don't set the
+ * field (e.g. dsl2ge) effectively get `false` here, which is the correct
+ * default for "full" parent containment.
+ *
+ * Lottie's parser sets `linkKind: 'transform-only'` when a child's parent
+ * relationship comes from `layer.parent` rather than precomp expansion;
+ * `applyPostProcess` consumes this to decide whether to advance the parent's
+ * activation track when the child starts earlier.
+ */
+export declare function isTransformOnlyParentLink(layer: IRLayerNode): boolean;

package/dist/ir2ge/ir/specific.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Read-side accessors for the `IRLayerNode.specific.lottie` slot.
+ *
+ * The shared generator must not branch on lottie semantics directly — every
+ * lottie-specific read goes through these helpers so the rest of `ir2ge` stays
+ * agnostic to the producing tool.
+ *
+ * `isTransformOnlyParentLink` used to live here, reading
+ * `specific.lottie.explicitParent`. It was promoted to a generic IR field
+ * (`IRLayerReference.linkKind`); the accessor now lives at `./parent-link.ts`.
+ */
+import type { IRLayerNode, LottieLayerSpecific } from '@vvfx/animation-ir';
+export type { LottieLayerSpecific };
+export declare function readLottieSpecific(layer: IRLayerNode): LottieLayerSpecific | undefined;

package/dist/ir2ge/post-process/ge-mask-remap.d.ts

@@ -0,0 +1,18 @@
+import type { ECSCollector } from '../types';
+/**
+ * Remap GE mask references after ge2ir round-trip.
+ *
+ * ge2ir carries each masked component's raw `mask` object verbatim (via
+ * `IRLayerNode.metadata.ge2ir.geMask`), but `mask.reference.id` still points at the
+ * ORIGINAL (GE1) mask-source component id, which ir2ge has regenerated. This
+ * pass rewrites every target's `reference.id` from the stale GE1 id to the
+ * freshly-minted GE2 component id, using the `geComponentId → newId` map built
+ * during the layer walk.
+ *
+ * Mirrors `applyParenting`: an IR-side reference (here the stale id stored in
+ * data) → map → regenerated id → written in place. Mask SOURCE components have
+ * no `reference` and are skipped. Dangling references (source not regenerated —
+ * e.g. dropped by the null+sprite merger) have their `mask` removed so the GE
+ * runtime doesn't choke on an id that resolves to nothing.
+ */
+export declare function applyGeMaskRemap(collector: ECSCollector, geComponentIdToNewId: Record<string, string>): void;

package/dist/ir2ge/post-process/index.d.ts

@@ -0,0 +1,31 @@
+import type { IRComposition } from '@vvfx/animation-ir';
+import type { ECSCollector, ProcessedItem } from '../types';
+import { type MaskLayerLookup } from './mask';
+export type { MaskLayerLookup } from './mask';
+/**
+ * Post-emit state populated by the unified pipeline's per-layer walk.
+ * All fields beyond `collector` + `processedItems` are optional — each
+ * post-process step is gated on the presence of the data it needs, not
+ * on `ir.source`. Steps that only apply to certain sources naturally
+ * no-op when the relevant data is absent (e.g. dsl IR has no masks).
+ */
+export interface PostProcessState {
+    collector: ECSCollector;
+    processedItems: ProcessedItem[];
+    /** Per-layer lookups consumed by the shared mask post-process. */
+    maskLookup?: MaskLayerLookup;
+    layerToItemId?: Record<number, string>;
+    parentIndexSet?: Set<number>;
+    ratio?: number;
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    /** GE1→GE2 component-id map for remapping ge2ir mask passthrough references. */
+    geComponentIdToNewId?: Record<string, string>;
+}
+/**
+ * Run post-emit mutations on the collector before `assembleScene`.
+ * Order: parenting → mask → visibility. Each step is gated on whether
+ * the pipeline supplied the required tracking state.
+ */
+export declare function applyPostProcess(ir: IRComposition, state: PostProcessState): void;

package/dist/ir2ge/post-process/mask.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Mask post-process: emits a mask shape item + component for each layer that
+ * carries `IRMaskData`, propagating the mask reference to the layer's renderer
+ * component or — for parent layers — to descendant renderers.
+ *
+ * The decision to emit (per-layer) is gated solely on `layer.mask != null`,
+ * so any IR producer can opt in by writing the field. Currently only lottie
+ * IR has masks; dsl IR leaves `mask` undefined and this module no-ops for it.
+ *
+ * The lookup callbacks let each pipeline plug in its own layer-to-emitted-id
+ * mapping — lottie keeps `layerToItemId`/`layerToComponentId`/`parentIndexSet`
+ * during emission, dsl tracks differently. Mask handling stays generic.
+ */
+import type { IRComposition } from '@vvfx/animation-ir';
+import type { ECSCollector, ProcessedItem } from '../types';
+/**
+ * Pipeline-specific lookups consumed during mask emission. A pipeline that
+ * never produces masks can pass stub callbacks (the iterator skips layers
+ * without `mask`, so the callbacks are never invoked in that case).
+ */
+export interface MaskLayerLookup {
+    getItemId(layerIndex: number): string | undefined;
+    getComponentId(layerIndex: number): string | undefined;
+    isParentLayer(layerIndex: number): boolean;
+}
+export declare function applyMasks(ir: IRComposition, collector: ECSCollector, processedItems: ProcessedItem[], ratio: number, width: number, height: number, frameRate: number, lookup: MaskLayerLookup): void;

package/dist/ir2ge/post-process/parenting.d.ts

@@ -0,0 +1,3 @@
+import type { IRLayerNode } from '@vvfx/animation-ir';
+import type { GEItem } from '../types';
+export declare function applyParenting(layers: IRLayerNode[], items: GEItem[], layerToItemId: Record<number, string>, ratio: number, width: number, height: number): void;

package/dist/ir2ge/post-process/visibility.d.ts

@@ -0,0 +1,26 @@
+interface ProcessedItemRef {
+    itemId: string;
+    objectBindingTrackId: string;
+}
+interface NormalizeVisibilityParams {
+    items: Record<string, unknown>[];
+    miscs: Record<string, unknown>[];
+    processedItems: ProcessedItemRef[];
+    /** Item IDs whose parent-child relationship only inherits transform, not visibility. */
+    transformOnlyParentLinkItemIds?: Set<string>;
+    roundNumber: (value: number, precision: number) => number;
+}
+/**
+ * Normalize child visibility delays so children never appear before their parent.
+ *
+ * Topologically sorts items (parent-first) so by the time we process any child
+ * its parent's delay/duration are already finalized. For transform-only
+ * parent-link children, we instead advance the parent's delay/duration so the
+ * child can render from its own start time (GE requires the parent to be active
+ * for transform inheritance, but the parent-link relationship does not propagate
+ * visibility). Only the ActivationTrack clip is updated; TransformTrack
+ * keyframes are normalized to the original time range and would hold their
+ * first frame value if the track started earlier.
+ */
+export declare function normalizeChildVisibilityByParentDelays({ items, miscs, processedItems, transformOnlyParentLinkItemIds, roundNumber, }: NormalizeVisibilityParams): void;
+export {};

package/dist/ir2ge/types.d.ts

@@ -0,0 +1,37 @@
+import type { IRComposition } from '@vvfx/animation-ir';
+import type { DataPath } from '@galacean/effects-specification';
+import type { ECSCollector } from '../shared/types';
+export type { ECSCollector, GEDataPath, GEItem, GEPoolIndex, GERecord, GETransform } from '../shared/types';
+/**
+ * Bookkeeping for a fully emitted item: its VFXItemData id and the
+ * ObjectBindingTrack that owns its child Activation/Transform/SpriteColor
+ * tracks. The optional `layerIndex` lets source-specific post-processing
+ * (e.g. lottie visibility normalization) trace items back to the IR layer.
+ */
+export interface ProcessedItem {
+    itemId: string;
+    objectBindingTrackId: string;
+    layerIndex?: number;
+}
+/** Per-channel animation payload consumed by the timeline tracks. */
+export interface TransformAnimation {
+    positionOverLifetime?: Record<string, unknown> | null;
+    rotationOverLifetime?: Record<string, unknown> | null;
+    sizeOverLifetime?: Record<string, unknown> | null;
+    colorOverLifetime?: Record<string, unknown> | null;
+}
+/** Per-layer context threaded through the unified layer processors. */
+export interface LayerProcessingContext {
+    /** Full IR composition; needed by shared accessors that dispatch on `ir.source`. */
+    ir: IRComposition;
+    collector: ECSCollector;
+    processedItems: ProcessedItem[];
+    layerToItemId: Record<number, string>;
+    layerToComponentId: Record<number, string>;
+    textureCache: Map<string, DataPath>;
+    parentIndexSet: Set<number>;
+    ratio: number;
+    width: number;
+    height: number;
+    frameRate: number;
+}

package/dist/ir2ge/utils.d.ts

@@ -0,0 +1,14 @@
+import type { DataPath } from '@galacean/effects-specification';
+/** Generate a 32-char hex GE entity id (UUID v4 with dashes stripped). */
+export declare function createId(): string;
+/** Wrap an id into a `{ id }` GE DataPath reference. */
+export declare function toDataPath(id: string): DataPath;
+/** Round a number to the given decimal precision (default 4). */
+export declare function roundNumber(value: number, precision?: number): number;
+/** Linear interpolation between `a` and `b` by `factor` ∈ [0, 1]. */
+export declare function lerp(a: number, b: number, factor: number): number;
+/**
+ * Rough text width estimate used when the IR layer does not record a
+ * measured width. Average character width ≈ 0.6 × fontSize.
+ */
+export declare function estimateTextWidth(text: string, fontSize: number, letterSpacing?: number): number;

package/dist/shared/coordinate.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_CAMERA_Z = 8;
+export declare const DEFAULT_CAMERA_FOV = 60;
+export declare const DEFAULT_CLIP_MODE = 1;
+/** 2D pixel space -> GE 3D world unit ratio for a given canvas size. */
+export declare function get2dTo3dRatio(width: number, height: number): number;
+/**
+ * Convert a 2D point in canvas pixel space (origin top-left) to a GE 3D world
+ * point (origin centered, Y flipped). The `z` parameter applies the GE camera
+ * adapter to stay perspective-correct for non-zero Z layers.
+ */
+export declare function convert2dTo3dPoint(x: number, y: number, z: number, width: number, height: number): [number, number, number];

package/dist/shared/ge2ir-metadata.d.ts

@@ -0,0 +1,17 @@
+import type { IRComposition, IRLayerNode } from '@vvfx/animation-ir';
+/**
+ * Round-trip passthrough contract written by ge2ir and consumed by ir2ge.
+ *
+ * Supported keys:
+ * positionOverLifetime, rotationOverLifetime, sizeOverLifetime,
+ * colorOverLifetime, geComponentId, geMask.
+ */
+export interface GE2IRPassthroughMetadata {
+    positionOverLifetime?: Record<string, unknown>;
+    rotationOverLifetime?: Record<string, unknown>;
+    sizeOverLifetime?: Record<string, unknown>;
+    colorOverLifetime?: Record<string, unknown>;
+    geComponentId?: string;
+    geMask?: Record<string, unknown>;
+}
+export declare function readGE2IRMetadata(ir: IRComposition, layer: IRLayerNode): GE2IRPassthroughMetadata | undefined;

package/dist/shared/types.d.ts

@@ -0,0 +1,60 @@
+import type { DataPath } from '@galacean/effects-specification';
+export type GERecord = Record<string, unknown>;
+export type GEDataPath = DataPath;
+export type GEPoolIndex = Map<string, GERecord>;
+/** GE transform block emitted on every VFX item. */
+export interface GETransform {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    eulerHint: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    anchor?: {
+        x: number;
+        y: number;
+    };
+    size?: {
+        x: number;
+        y: number;
+    };
+}
+/** A single VFXItemData entry in a GE scene. */
+export interface GEItem {
+    id: string;
+    dataType: string;
+    name: string;
+    duration: number;
+    type: string;
+    visible: boolean;
+    endBehavior: number;
+    delay: number;
+    renderLevel: string;
+    content?: GERecord;
+    components: GEDataPath[];
+    transform: GETransform;
+    parentId?: string;
+}
+/**
+ * Build-time accumulators shared by every generator. Each pool maps to a
+ * top-level array on the emitted JSONScene.
+ */
+export interface ECSCollector {
+    images: Array<{
+        id: string;
+        url: string;
+    }>;
+    components: GERecord[];
+    items: GEItem[];
+    textures: GERecord[];
+    miscs: GERecord[];
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@vvfx/ge-ir",
+  "version": "0.0.1-beat.2",
+  "description": "Galacean Effects and animation IR bidirectional conversion package",
+  "module": "./dist/index.mjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@galacean/effects-specification": "^2.8.0",
+    "uuid": "^13.0.0",
+    "@vvfx/animation-ir": "0.0.1-beat.2"
+  },
+  "contributors": [
+    {
+      "name": "澄弈"
+    }
+  ],
+  "author": "Ant Group CO., Ltd.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "prebuild": "pnpm clean",
+    "build": "pnpm build:declaration && pnpm build:module",
+    "build:module": "rollup -c --bundleConfigAsCjs",
+    "build:declaration": "tsc -b ../animation-ir tsconfig.json --emitDeclarationOnly",
+    "clean": "rimraf dist *.tsbuildinfo",
+    "test": "vitest run"
+  }
+}