@forgeax/engine-vfx 0.1.4 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-vfx",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -29,10 +29,10 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@forgeax/engine-assets-runtime": "0.1.4",
-    "@forgeax/engine-ecs": "0.1.4",
-    "@forgeax/engine-plugin": "0.1.4",
-    "@forgeax/engine-types": "0.1.4"
+    "@forgeax/engine-assets-runtime": "0.1.7",
+    "@forgeax/engine-ecs": "0.1.7",
+    "@forgeax/engine-plugin": "0.1.7",
+    "@forgeax/engine-types": "0.1.7"
   },
   "forgeax": {
     "metrics": {

package/src/__tests__/channel-overflow-policy-owner.test-d.ts

@@ -0,0 +1,55 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, expectTypeOf, it } from 'vitest';
+import type {
+  ParticleChannelOverflowPolicy,
+  ParticleChannelSource,
+  ParticleRendererOverflowPolicy,
+  ParticleRendererSource,
+} from '../code-source.js';
+import type {
+  ParticleChannelOverflowPolicy as PublicParticleChannelOverflowPolicy,
+  ParticleRendererOverflowPolicy as PublicParticleRendererOverflowPolicy,
+} from '../index.js';
+
+type BillboardRenderer = Extract<ParticleRendererSource, { readonly kind: 'billboard' }>;
+type RendererOverflow = BillboardRenderer['overflow'];
+type ChannelOverflow = ParticleChannelSource['overflow'];
+type RendererOverflowSlot = Pick<BillboardRenderer, 'overflow'>;
+type ChannelOverflowSlot = Pick<ParticleChannelSource, 'overflow'>;
+
+const codeSource = readFileSync(new URL('../code-source.ts', import.meta.url), 'utf8');
+
+describe('VFX channel overflow policy owner', () => {
+  it('derives the channel policy from the renderer policy without changing field presence', () => {
+    expectTypeOf<ParticleChannelOverflowPolicy>().toEqualTypeOf<ParticleRendererOverflowPolicy>();
+    expectTypeOf<ParticleRendererOverflowPolicy>().toEqualTypeOf<ParticleChannelOverflowPolicy>();
+    expectTypeOf<PublicParticleChannelOverflowPolicy>().toEqualTypeOf<ParticleChannelOverflowPolicy>();
+    expectTypeOf<PublicParticleRendererOverflowPolicy>().toEqualTypeOf<ParticleRendererOverflowPolicy>();
+    expectTypeOf<RendererOverflow>().toEqualTypeOf<ParticleRendererOverflowPolicy | undefined>();
+    expectTypeOf<ParticleRendererOverflowPolicy | undefined>().toEqualTypeOf<RendererOverflow>();
+    expectTypeOf<ChannelOverflow>().toEqualTypeOf<ParticleChannelOverflowPolicy>();
+    expectTypeOf<ParticleChannelOverflowPolicy>().toEqualTypeOf<ChannelOverflow>();
+    expectTypeOf<RendererOverflowSlot>().toEqualTypeOf<{
+      readonly overflow?: ParticleRendererOverflowPolicy;
+    }>();
+    expectTypeOf<ChannelOverflowSlot>().toEqualTypeOf<{
+      readonly overflow: ParticleChannelOverflowPolicy;
+    }>();
+  });
+
+  it('keeps exactly the drop-newest and drop-oldest members', () => {
+    expectTypeOf<ParticleChannelOverflowPolicy>().toEqualTypeOf<'drop-newest' | 'drop-oldest'>();
+    expectTypeOf<'drop-newest'>().toExtend<ParticleChannelOverflowPolicy>();
+    expectTypeOf<'drop-oldest'>().toExtend<ParticleChannelOverflowPolicy>();
+    expectTypeOf<'drop-other'>().not.toExtend<ParticleChannelOverflowPolicy>();
+  });
+
+  it('keeps the authored renderer policy as the only production owner', () => {
+    expect(codeSource).toContain(
+      'export type ParticleChannelOverflowPolicy = ParticleRendererOverflowPolicy;',
+    );
+    expect(codeSource).not.toContain(
+      "export type ParticleChannelOverflowPolicy = 'drop-newest' | 'drop-oldest';",
+    );
+  });
+});

package/src/__tests__/loader-v1-rejection.unit.test.ts

@@ -1,6 +1,5 @@
 import type { LoadContext } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { particleEffectContribution } from '../assets/particle-effect-decoder.js';
 import { vfxGpuEffectPackLoader } from '../index.js';
 
 const EFFECT_GUID = '019e2cc6-0c86-79da-aa76-b0984c86d45c';
@@ -38,10 +37,6 @@ const validPayload = {
 };
 
 describe('vfxGpuEffectPackLoader v2 boundary', () => {
-  it('exposes the cooked particle owner contribution', () => {
-    expect(particleEffectContribution.kind.kind).toBe('particle-effect');
-    expect(particleEffectContribution.consumer).toBe('VfxGpuRuntime');
-  });
   it('keeps legacy artifact keys outside the v2 asset-local program contract', async () => {
     const result = await vfxGpuEffectPackLoader.load(
       input(validPayload, {
@@ -107,19 +102,4 @@ describe('vfxGpuEffectPackLoader v2 boundary', () => {
       expect(result.error.detail.path).toBe('payload');
     }
   });
-
-  it('keeps the particle owner on the asset-local cooked program contract', async () => {
-    const result = await vfxGpuEffectPackLoader.load(
-      input({
-        kind: 'particle-effect',
-        schemaVersion: 2,
-        emitters: [],
-        programFingerprint: 'sha256:x',
-      }),
-      context(),
-    );
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error.code).toBe('vfx-asset-v2-invalid');
-  });
 });

package/src/code-source.ts

@@ -77,7 +77,7 @@ export type ParticleRendererSource =
       readonly width?: number;
     };
 
-export type ParticleChannelOverflowPolicy = 'drop-newest' | 'drop-oldest';
+export type ParticleChannelOverflowPolicy = ParticleRendererOverflowPolicy;
 
 export type ParticleStageDomain = 'particle';
 export type ParticleStageResourceAccess = 'read' | 'write' | 'read-write';

package/src/gpu-loader.ts

@@ -1,4 +1,7 @@
-import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import type {
+  AssetRegistry as LegacyAssetRegistry,
+  RuntimeAssetRegistry,
+} from '@forgeax/engine-assets-runtime';
 import type {
   AssetDecoderContribution,
   AssetKind,
@@ -230,7 +233,7 @@ export const vfxGpuEffectPackLoader = {
   },
 };
 
-/** VFX owner decoder contribution for the single runtime decoder map. */
+/** VFX owner decoder contribution for the core registry's typed map. */
 export const vfxGpuEffectContribution: AssetDecoderContribution<
   VfxGpuEffectAsset,
   'particle-effect'
@@ -272,8 +275,17 @@ export const vfxGpuEffectContribution: AssetDecoderContribution<
 };
 
 export async function loadVfxGpuEffect(
-  registry: AssetRegistry,
+  registry: LegacyAssetRegistry | RuntimeAssetRegistry,
   guid: string,
 ): Promise<Result<VfxGpuEffectAsset, unknown>> {
-  return registry.load(guid, vfxGpuEffectContribution.kind);
+  if ('load' in registry) {
+    return registry.load(guid, vfxGpuEffectContribution.kind);
+  }
+  let parsed: ReturnType<LegacyAssetRegistry['parseGuid']>;
+  try {
+    parsed = registry.parseGuid(guid);
+  } catch (error) {
+    return err(error);
+  }
+  return registry.loadByGuid<VfxGpuEffectAsset>(parsed);
 }

package/src/index.ts

@@ -1,7 +1,7 @@
 // @forgeax/engine-vfx - runtime-safe code-first GPU VFX contract.
 
 export type { ParticleEffectAsset, ParticleEmitterDefinition } from '@forgeax/engine-types';
-export { particleEffectContribution } from './assets/particle-effect-decoder.js';
+export { particleEffectContribution } from './assets/particle-effect-decoder';
 export type {
   VfxAuthoringCapabilityDescriptor,
   VfxAuthoringDependencyDescriptor,