@forgeax/engine-pack 0.1.32 → 0.1.34

package/src/__tests__/pack-authoring-gateway.unit.test.ts

@@ -1,4 +1,4 @@
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
@@ -296,3 +296,73 @@ describe('Pack authoring gateway', () => {
     expect(verified).toMatchObject({ ok: true, value: { summary: { assetCount: 1 } } });
   });
 });
+
+it('inspects the exact source revision used by rebuild conflict checks', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'forgeax-inspect-revision-'));
+  roots.push(root);
+  const outputs = [
+    {
+      packageId: SOURCE_PACKAGE,
+      sourceKey: 'mesh/main',
+      guid: AssetGuid.format(AssetGuid.derive(packageId(SOURCE_PACKAGE), 'mesh/main')),
+      kind: 'mesh',
+      sourcePath: 'assets/source.pack.ts',
+      ready: true,
+    },
+  ];
+  let published = false;
+  const gateway = createFileSystemPackAuthoringGateway({
+    gameRoot: root,
+    materialized: () => (published ? outputs : []),
+    rebuild: async () => ({ ok: true, value: undefined }),
+  });
+  const created = await gateway.execute({
+    operation: 'asset-source.create',
+    requestId: 'create',
+    targetPath: 'assets/source.pack.ts',
+    format: 'pack.ts',
+    packageId: SOURCE_PACKAGE,
+  });
+  expect(created.ok).toBe(true);
+  if (!created.ok) return;
+  published = true;
+  const inspected = await gateway.execute({
+    operation: 'asset.inspect',
+    subject: 'assets/source.pack.ts',
+    requestId: 'inspect',
+  });
+  expect(inspected).toMatchObject({
+    ok: true,
+    value: {
+      revision: created.value.revision,
+      sourcePath: 'assets/source.pack.ts',
+      assets: outputs,
+    },
+  });
+  const rebuilt = await gateway.execute({
+    operation: 'asset-source.rebuild',
+    sourcePath: 'assets/source.pack.ts',
+    expectedRevision: created.value.revision,
+    requestId: 'rebuild',
+  });
+  expect(rebuilt).toMatchObject({
+    ok: true,
+    value: { assets: outputs, revision: created.value.revision },
+  });
+  const path = join(root, 'assets/source.pack.ts');
+  await writeFile(path, `${await readFile(path, 'utf8')}\n// source edit\n`);
+  const changed = await gateway.execute({
+    operation: 'asset.inspect',
+    subject: 'assets/source.pack.ts',
+    requestId: 'inspect-edited',
+  });
+  expect(changed.ok).toBe(true);
+  if (changed.ok) expect(changed.value.revision).not.toBe(created.value.revision);
+  const stale = await gateway.execute({
+    operation: 'asset-source.rebuild',
+    sourcePath: 'assets/source.pack.ts',
+    expectedRevision: created.value.revision,
+    requestId: 'stale',
+  });
+  expect(stale).toMatchObject({ ok: false, error: { code: 'pack-source-revision-conflict' } });
+});

package/src/__tests__/pack-authoring.unit.test.ts

@@ -21,6 +21,32 @@ function packageId(value: string) {
 }
 
 describe('ScriptablePack and Pack authoring', () => {
+  it('accepts boolean and string defaults and overrides without coercion', () => {
+    const definition = definePack({
+      schemaVersion: '2.0.0',
+      packageId: definePackageId('01900000-0000-7000-8000-000000000031'),
+      parameters: [
+        { name: 'animated', type: 'bool', default: true },
+        { name: 'label', type: 'string', default: 'smoke' },
+      ],
+      build: () => ok({ 'scene/main': { kind: 'scene', entities: {} } }),
+    });
+    expect(resolvePackParameterValues(definition, {})).toMatchObject({
+      ok: true,
+      value: { animated: true, label: 'smoke' },
+    });
+    expect(resolvePackParameterValues(definition, { animated: false, label: '' })).toMatchObject({
+      ok: true,
+      value: { animated: false, label: '' },
+    });
+    for (const values of [{ animated: 'false' }, { animated: 0 }, { label: false }, { label: 0 }]) {
+      expect(resolvePackParameterValues(definition, values)).toMatchObject({
+        ok: false,
+        error: { code: 'pack-parameter-invalid' },
+      });
+    }
+  });
+
   it('derives the RFC 4122 UUIDv5 vector and keeps PackageId branded separately', () => {
     const namespace = packageId(NAMESPACE);
     expect(AssetGuid.format(AssetGuid.derive(namespace, 'www.widgets.com'))).toBe(

package/src/evidence/material-cook.ts

@@ -4,6 +4,7 @@ import type {
   MaterialPass,
   MaterialProgramAbi,
   MaterialProgramAddress,
+  MaterialSurfaceDeclaration,
   MaterialTextureReference,
   MaterialTextureValue,
   MaterialValue,
@@ -13,6 +14,7 @@ import {
   deriveStandardLayerPlan,
   err,
   isMaterialProgramAbi,
+  isMaterialSurfaceDeclaration,
   MATERIAL_TEXTURE_SLOTS,
   ok,
 } from '@forgeax/engine-types';
@@ -120,6 +122,7 @@ export interface CookedMaterialRecord {
     readonly passes: readonly MaterialPass[];
     readonly parameters: readonly MaterialParameter[];
     readonly values: Readonly<Record<string, MaterialValue | null>>;
+    readonly surface?: MaterialSurfaceDeclaration;
   };
   readonly refs: MaterialCookRefs;
   readonly receipt: MaterialCookReceipt;
@@ -231,7 +234,10 @@ export function collectMaterialCookRefs(material: Partial<MaterialAsset>): Mater
         return guid === undefined ? [] : [guid];
       }),
     ),
-    modules: unique((material.passes ?? []).map((pass) => pass.program.module)),
+    modules: unique([
+      ...(material.passes ?? []).map((pass) => pass.program.module),
+      ...(material.surface === undefined ? [] : [material.surface.module]),
+    ]),
   };
 }
 
@@ -476,6 +482,8 @@ export function validateCookedMaterialRecord(
     Array.isArray(resolved.values)
   )
     return invalid('resolved.values', resolved.values);
+  if (resolved.surface !== undefined && !isMaterialSurfaceDeclaration(resolved.surface))
+    return invalid('resolved.surface', resolved.surface);
   const passes = resolved.passes as MaterialPass[];
   const passNames = new Set<string>();
   for (const [index, pass] of passes.entries()) {

package/src/pack-authoring-node.ts

@@ -817,6 +817,19 @@ async function inspectAsset(
   const selected = subjectFor(gameRoot, snapshot, operation);
   if (!selected.ok) return selected;
   const subject = selected.value;
+  const source = await readConfined({ gameRoot }, operation, subject.relativePath);
+  if (!source.ok) return source;
+  const inspectedSource = {
+    ...sourceResult(subject, operation),
+    revision: source.value.revision,
+    ...(subject.format === 'source'
+      ? {
+          assets: snapshot.materialized
+            .filter((asset) => asset.packageId === packageKey(subject.packageId))
+            .map((asset) => ({ ...asset })),
+        }
+      : {}),
+  };
   if (operation.sourceKey !== undefined) {
     if (!isValidPackSourceKey(operation.sourceKey)) {
       return err(
@@ -851,7 +864,7 @@ async function inspectAsset(
           candidate.sourceKey === operation.sourceKey,
       );
       return ok({
-        ...sourceResult(subject, operation),
+        ...inspectedSource,
         sourceKey: asset.sourceKey,
         guid: asset.guid,
         kind: asset.kind,
@@ -871,7 +884,7 @@ async function inspectAsset(
           candidate.sourceKey === operation.sourceKey,
       );
       return ok({
-        ...sourceResult(subject, operation),
+        ...inspectedSource,
         sourceKey: operation.sourceKey,
         guid,
         ...(materialized === undefined
@@ -897,7 +910,7 @@ async function inspectAsset(
     const resolved = await resolveInstance(snapshot, subject);
     if (!resolved.ok) return resolved;
     return ok({
-      ...sourceResult(subject, operation),
+      ...inspectedSource,
       parameters: resolved.value.parameters.map((parameter) => ({
         name: parameter.name,
         type: parameter.type,
@@ -911,7 +924,7 @@ async function inspectAsset(
       parentChain: resolved.value.parentChain,
     });
   }
-  return ok(sourceResult(subject, operation));
+  return ok(inspectedSource);
 }
 
 function listAssets(
@@ -2188,6 +2201,9 @@ async function executeRaw(
       selected.value.packageId,
       {
         format: refreshed.value.relative.endsWith('.pack.json') ? 'pack.json' : 'pack.ts',
+        assets: refreshedSnapshot.value.materialized
+          .filter((asset) => asset.packageId === packageKey(selected.value.packageId))
+          .map((asset) => ({ ...asset })),
       },
     );
   }

package/src/pack-authoring.ts

@@ -256,8 +256,10 @@ function parameterValueError(
   propertyPath: string,
 ): PackAuthoringError | undefined {
   const { type } = parameter;
-  if (type === 'bool' && typeof value !== 'boolean') {
-    return parameterFailure(propertyPath, 'a boolean', value, 'bool value has the wrong type');
+  if (type === 'bool') {
+    return typeof value === 'boolean'
+      ? undefined
+      : parameterFailure(propertyPath, 'a boolean', value, 'bool value has the wrong type');
   }
   if (numericType(type)) {
     if (typeof value !== 'number' || !Number.isFinite(value)) {
@@ -318,8 +320,10 @@ function parameterValueError(
     }
     return undefined;
   }
-  if (type === 'string' && typeof value !== 'string') {
-    return parameterFailure(propertyPath, 'a string', value, 'string parameter has the wrong type');
+  if (type === 'string') {
+    return typeof value === 'string'
+      ? undefined
+      : parameterFailure(propertyPath, 'a string', value, 'string parameter has the wrong type');
   }
   if (type === 'enum') {
     if (typeof value !== 'string') {

package/src/schema/material-cook.schema.json

@@ -52,7 +52,80 @@
     },
     "resolved": {
       "type": "object",
-      "required": ["passes", "parameters", "values"]
+      "required": ["passes", "parameters", "values"],
+      "properties": {
+        "surface": {
+          "type": "object",
+          "required": ["model", "module"],
+          "properties": {
+            "model": {
+              "enum": ["standard", "single-layer-medium"]
+            },
+            "module": {
+              "type": "string",
+              "minLength": 1
+            },
+            "dynamicInput": {
+              "type": "object",
+              "required": [
+                "name",
+                "fields",
+                "maxRecords",
+                "maxDomains",
+                "maxPageBytes",
+                "maxBindings",
+                "maxEventsPerSample"
+              ],
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
+                },
+                "fields": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "object",
+                    "required": ["name", "type"],
+                    "properties": {
+                      "name": {
+                        "type": "string",
+                        "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
+                      },
+                      "type": {
+                        "enum": ["f32", "u32", "vec2<f32>", "vec3<f32>", "vec4<f32>"]
+                      }
+                    },
+                    "additionalProperties": false
+                  }
+                },
+                "maxRecords": {
+                  "type": "integer",
+                  "minimum": 1
+                },
+                "maxDomains": {
+                  "type": "integer",
+                  "minimum": 1
+                },
+                "maxPageBytes": {
+                  "type": "integer",
+                  "minimum": 1
+                },
+                "maxBindings": {
+                  "type": "integer",
+                  "minimum": 1
+                },
+                "maxEventsPerSample": {
+                  "type": "integer",
+                  "minimum": 1
+                }
+              },
+              "additionalProperties": false
+            }
+          },
+          "additionalProperties": false
+        }
+      }
     },
     "refs": {
       "type": "object",