create-aura3d 1.5.2 → 2.0.1

package/dist/showcase-spec-game-geometry-extractor.js

@@ -14,7 +14,7 @@ const RACING_MAX_AUTHORED_LAP_SECONDS = 60;
  * surface. Small excursions are tolerated where kerb triangles are modelled with
  * gaps; a route that is mostly off-road is rejected outright.
  */
-const RACING_MAX_OFF_ROAD_RATIO = 0.08;
+const RACING_MAX_OFF_ROAD_RATIO = 0.01;
 /**
  * Maximum ratio between the widest and tightest radius of a derived racing loop.
  * Real circuits vary; a route that bulges out across an attached apron does not.
@@ -47,6 +47,8 @@ const PLATFORMER_DEFAULT_CHARACTER_FOOTPRINT_WIDTH = 0.72;
 const PLATFORMER_MAX_HORIZONTAL_TRAVERSAL_GAP = 8;
 const PLATFORMER_MAX_UPWARD_TRAVERSAL_STEP = 2.5;
 const PLATFORMER_MAX_RETAINED_MESH_SURFACES = 16;
+const PLATFORMER_MAX_DECLARED_RETAINED_MESH_SURFACES = 256;
+const PLATFORMER_AUTHORED_WORLD_GENERATOR = "Aura3D Skyline Level 1 deterministic GLB compositor";
 const PLATFORMER_DECORATIVE_PATTERN = /\b(column|pillar|tower|decor|background|backdrop)\b/i;
 /**
  * Memoizes racing extraction per asset. Ranking a replacement candidate list calls
@@ -73,6 +75,23 @@ export function extractRacingTrackTopologyFromAsset(assetId, options = {}) {
 export function clearRacingTrackTopologyCache() {
     racingTopologyCache.clear();
 }
+/** Internal evidence probe used by the top-down racing audit and regression tests. */
+export function diagnoseRacingPrimitiveCoverage(assetId, options = {}) {
+    const projectDir = options.projectDir ?? process.cwd();
+    const geometry = loadAssetGeometry(assetId, projectDir);
+    const topology = extractRacingTrackTopologyFromAsset(assetId, options);
+    if (!geometry.ok || !topology.ok)
+        return [];
+    return geometry.value.primitives.filter(isRoadPrimitive).map((primitive) => {
+        const surface = createRoadSurface([primitive]);
+        return {
+            materialName: primitive.materialName,
+            triangleCount: primitive.triangles.length,
+            routeCoverage: round4(1 - measureOffRoadRatio(topology.value.roadCenterline, surface)),
+            bounds: primitive.bounds
+        };
+    }).sort((a, b) => b.routeCoverage - a.routeCoverage || b.triangleCount - a.triangleCount);
+}
 function computeRacingTrackTopology(assetId, options, projectDir) {
     const geometry = loadAssetGeometry(assetId, projectDir);
     if (!geometry.ok)
@@ -112,15 +131,35 @@ function computeRacingTrackTopology(assetId, options, projectDir) {
         return failure([`asset-extraction:racing-road-centerline-zero-length:${assetId}`], [`Road mesh in ${assetId} did not produce a measurable closed route.`]);
     }
     const checkpointCount = 6;
+    const drivableMesh = createDrivableMesh(roadPrimitives);
     const topology = {
         assetId,
         assetHash: requireAssetHash(geometry.value.asset),
         source: "asset-mesh-extracted",
-        roadCenterline: centerline,
+        /*
+         * Centreline points carry the measured surface elevation under each point.
+         *
+         * Sampling the drivable surface here is what lets a route drop its frozen
+         * `TRACK_SURFACE_Y` constant: the vertical road profile becomes data extracted from the
+         * asset rather than a number a route author had to guess and then defend in a comment.
+         */
+        roadCenterline: centerline.map((point) => {
+            const surfaceY = roadSurface.elevationAt(point.x, point.z);
+            return surfaceY === undefined ? point : { ...point, surfaceY: round3(surfaceY) };
+        }),
         checkpoints: Array.from({ length: checkpointCount }, (_unused, index) => ({
             progress: round3((index + 1) / checkpointCount),
             width: centerline[index % centerline.length]?.width ?? averageRoadWidth(roadSize)
         })),
+        /*
+         * The drivable surface itself, so a route can ground each wheel independently.
+         *
+         * The centreline profile above still describes the racing line, but a curve cannot
+         * express camber or banking across the road's width. Emitting triangles is what lets
+         * the racing route delete its surface constants outright instead of trading one
+         * approximation for a slightly better one.
+         */
+        ...(drivableMesh ? { drivableMesh } : {}),
         lapLengthMeters: round3(lapLength),
         estimatedLapSeconds: Math.min(RACING_MAX_AUTHORED_LAP_SECONDS, Math.max(30, Math.ceil(lapLength / RACING_CERTIFIED_GAME_UNITS_PER_SECOND))),
         confidence: 0.76,
@@ -160,7 +199,8 @@ function computeRacingTrackTopology(assetId, options, projectDir) {
             `estimatedLapSeconds:${topology.estimatedLapSeconds}`,
             `centerlineMethod:${centerlineMethod}`,
             `centerlineOffRoadRatio:${offRoadRatio.toFixed(4)}`,
-            `roadTriangles:${roadSurface.triangleCount}`
+            `roadTriangles:${roadSurface.triangleCount}`,
+            `drivableMeshTriangles:${drivableMesh?.triangleCount ?? 0}`
         ]
     };
 }
@@ -183,7 +223,7 @@ export function extractPlatformerPlayableSurfaceMapFromAsset(assetId, options =
     if (horizontalCandidates.length === 0) {
         return failure([`asset-extraction:platformer-horizontal-surfaces-not-found:${assetId}`], [`${assetId} has ${surfaceSelection.primitives.length} candidate primitive(s), but none are flat enough for playable surfaces.`]);
     }
-    const prepared = preparePlatformerSurfacePrimitives(assetId, horizontalCandidates, surfaceBounds, platformerCharacterFootprintWidth(options, options.projectDir ?? process.cwd()));
+    const prepared = preparePlatformerSurfacePrimitives(assetId, horizontalCandidates, surfaceBounds, platformerCharacterFootprintWidth(options, options.projectDir ?? process.cwd()), geometry.value.platformerAuthoring);
     if (prepared.blockers.length > 0) {
         return failure(prepared.blockers, [
             `${assetId} produced ${horizontalCandidates.length} flat candidate primitive(s), but no retained depth-coherent traversable chain met the public platformer geometry floor.`,
@@ -191,7 +231,7 @@ export function extractPlatformerPlayableSurfaceMapFromAsset(assetId, options =
             ...surfaceSelection.reasons
         ]);
     }
-    const surfaces = createPlayableSurfaces(prepared.primitives, surfaceBounds);
+    const surfaces = createPlayableSurfaces(prepared.primitives, surfaceBounds, geometry.value.platformerAuthoring);
     const meshPlayableSurfaces = meshBoundPlayableSurfaces(surfaces);
     const qualityBlockers = platformerMeshSurfaceQualityBlockers(assetId, meshPlayableSurfaces);
     if (qualityBlockers.length > 0) {
@@ -209,7 +249,8 @@ export function extractPlatformerPlayableSurfaceMapFromAsset(assetId, options =
         source: "asset-mesh-extracted",
         surfaces,
         levelLength: round3(levelLength),
-        estimatedCompletionSeconds: Math.max(30, Math.ceil(levelLength / 0.9)),
+        estimatedCompletionSeconds: geometry.value.platformerAuthoring?.authoredCompletionSeconds
+            ?? Math.max(30, Math.ceil(levelLength / 0.9)),
         characterScaleRatio: 0.42,
         confidence: 0.74,
         modelAlignment: {
@@ -220,7 +261,7 @@ export function extractPlatformerPlayableSurfaceMapFromAsset(assetId, options =
                 x: round3(levelLength / 2),
                 y: 0
             },
-            anchorPairs: createPlatformerAnchorPairs(surfaces, surfaceBounds),
+            anchorPairs: createPlatformerAnchorPairs(surfaces, surfaceBounds, geometry.value.platformerAuthoring),
             evidence: {
                 ...(options.routeOverlayPath ? { routeOverlay: options.routeOverlayPath } : {}),
                 notes: "Mesh-derived playable-surface anchors are computed from flat platform/world primitives and bind the generated level to the visible world asset with the same model-to-game scale used by the generated level."
@@ -246,8 +287,8 @@ export function extractPlatformerPlayableSurfaceMapFromAsset(assetId, options =
         ]
     };
 }
-function preparePlatformerSurfacePrimitives(assetId, primitives, bounds, characterFootprintWidth) {
-    const modelToGameScale = platformerModelToGameScale(bounds);
+function preparePlatformerSurfacePrimitives(assetId, primitives, bounds, characterFootprintWidth, authoring) {
+    const modelToGameScale = platformerModelToGameScale(bounds, authoring);
     const minimumWalkableWidth = Math.max(PLATFORMER_DEFAULT_CHARACTER_FOOTPRINT_WIDTH, characterFootprintWidth);
     const uniquePrimitives = uniquePlayableSurfacePrimitives(primitives);
     const walkable = uniquePrimitives.filter((primitive) => primitive.size[0] * modelToGameScale >= minimumWalkableWidth);
@@ -268,11 +309,11 @@ function preparePlatformerSurfacePrimitives(assetId, primitives, bounds, charact
             reasons: []
         };
     }
-    const familySurfaces = candidatePlatformerSurfaces(selectedFamily.primitives, bounds);
+    const familySurfaces = candidatePlatformerSurfaces(selectedFamily.primitives, bounds, authoring);
     const columnResolution = resolveAmbiguousPlatformerColumns(assetId, familySurfaces);
     const retainedPrimitiveKeys = new Set(columnResolution.surfaces.map((surface) => surface.primitiveKey));
     const columnResolvedPrimitives = selectedFamily.primitives.filter((primitive) => retainedPrimitiveKeys.has(platformerPrimitiveKey(primitive)));
-    const traversal = selectPlatformerTraversalComponent(columnResolvedPrimitives, bounds);
+    const traversal = selectPlatformerTraversalComponent(columnResolvedPrimitives, bounds, authoring);
     const familyReasons = families
         .filter((family) => family !== selectedFamily)
         .map((family, index) => `excluded depth family ${index + 1} with ${family.primitives.length} primitive(s) at model z ${round3(family.minZ)}..${round3(family.maxZ)}`);
@@ -337,8 +378,8 @@ function platformerDepthFamilyScore(family, modelToGameScale) {
     }, 0);
     return ((maxX - minX) * modelToGameScale + family.primitives.length * 0.5) * 1_000 + semanticScore;
 }
-function candidatePlatformerSurfaces(primitives, bounds) {
-    const modelToGameScale = platformerModelToGameScale(bounds);
+function candidatePlatformerSurfaces(primitives, bounds, authoring) {
+    const modelToGameScale = platformerModelToGameScale(bounds, authoring);
     const baseline = Math.min(...primitives.map((primitive) => primitive.bounds.max[1]));
     return primitives.map((primitive, index) => ({
         id: `candidate-platform-${String(index).padStart(2, "0")}`,
@@ -385,8 +426,8 @@ function resolveAmbiguousPlatformerColumns(assetId, surfaces) {
         : [];
     return { surfaces: resolved, blockers, reasons };
 }
-function selectPlatformerTraversalComponent(primitives, bounds) {
-    const surfaces = [...candidatePlatformerSurfaces(primitives, bounds)].sort((a, b) => (a.x - a.width / 2) - (b.x - b.width / 2) || a.y - b.y);
+function selectPlatformerTraversalComponent(primitives, bounds, authoring) {
+    const surfaces = [...candidatePlatformerSurfaces(primitives, bounds, authoring)].sort((a, b) => (a.x - a.width / 2) - (b.x - b.width / 2) || a.y - b.y);
     const components = [];
     let current = [];
     let currentRight = Number.NEGATIVE_INFINITY;
@@ -469,7 +510,10 @@ function loadAssetGeometry(assetId, projectDir) {
         value: {
             asset,
             primitives,
-            bounds: boundsForPrimitives(primitives)
+            bounds: boundsForPrimitives(primitives),
+            ...(readPlatformerAuthoringMetadata(document.value) ? {
+                platformerAuthoring: readPlatformerAuthoringMetadata(document.value)
+            } : {})
         },
         reasons: [`read ${primitives.length} GLB primitive(s) from ${assetPath}`]
     };
@@ -632,7 +676,7 @@ function isPlatformPrimitive(primitive) {
     return PLATFORM_PATTERN.test(label) && !PLATFORM_EXCLUDE_PATTERN.test(label);
 }
 function selectPlatformerSurfacePrimitives(geometry) {
-    const geometric = geometry.primitives.filter((primitive) => isGenericPlatformerSurfacePrimitive(primitive, geometry.bounds));
+    const geometric = geometry.primitives.filter((primitive) => isGenericPlatformerSurfacePrimitive(primitive, geometry.bounds, geometry.platformerAuthoring));
     const positive = geometric.filter(isPlatformPrimitive).length;
     const decorative = geometric.filter((primitive) => PLATFORMER_DECORATIVE_PATTERN.test(`${primitive.nodeName} ${primitive.meshName} ${primitive.materialName}`)).length;
     return {
@@ -643,16 +687,23 @@ function selectPlatformerSurfacePrimitives(geometry) {
             : ["no flat horizontal primitive passed the game-surface footprint filter"]
     };
 }
-function isGenericPlatformerSurfacePrimitive(primitive, modelBounds) {
+function isGenericPlatformerSurfacePrimitive(primitive, modelBounds, authoring) {
     if (!isHorizontalSurface(primitive))
         return false;
     const modelSize = boundsSize(modelBounds);
-    const modelFootprint = Math.max(0.001, modelSize[0] * modelSize[2]);
+    // A composed authored level repeats local platform modules across a much longer
+    // X span. Comparing each module with the entire 923-unit world incorrectly
+    // rejects the smaller floating ledges purely because the level has ten districts.
+    // The signed compositor metadata supplies the immutable source-section span so
+    // local walkability is judged against one authored district, while the normal
+    // extractor remains unchanged for arbitrary third-party GLBs.
+    const effectiveModelWidth = authoring?.sectionModelSpan ?? modelSize[0];
+    const modelFootprint = Math.max(0.001, effectiveModelWidth * modelSize[2]);
     const primitiveFootprint = primitive.size[0] * primitive.size[2];
     const longestAxis = Math.max(primitive.size[0], primitive.size[2]);
     const shortestAxis = Math.min(primitive.size[0], primitive.size[2]);
     return primitiveFootprint >= Math.max(0.08, modelFootprint * 0.00045) &&
-        longestAxis >= Math.max(0.7, modelSize[0] * 0.006) &&
+        longestAxis >= Math.max(0.7, effectiveModelWidth * 0.006) &&
         shortestAxis >= 0.16;
 }
 function isHorizontalSurface(primitive) {
@@ -667,6 +718,66 @@ function sortPlayableSurfaceCandidate(a, b) {
         return areaDelta;
     return a.bounds.min[0] - b.bounds.min[0];
 }
+/**
+ * Build an indexed triangle mesh from the road primitives' triangles.
+ *
+ * Vertices are welded on a quantised key so shared corners collapse, which typically cuts
+ * the position array by about a third and, more importantly, makes the mesh watertight
+ * enough that a downward ray cannot slip through a seam between two adjacent road quads.
+ *
+ * `maxTriangles` bounds the committed artifact. Decimation keeps an evenly spaced subset
+ * rather than a contiguous prefix, because dropping a contiguous run would delete a whole
+ * corner of the circuit and leave a hole a wheel could fall through.
+ */
+function createDrivableMesh(primitives, maxTriangles = 4000) {
+    const triangles = primitives.flatMap((primitive) => primitive.triangles);
+    if (triangles.length === 0)
+        return undefined;
+    const stride = triangles.length > maxTriangles ? Math.ceil(triangles.length / maxTriangles) : 1;
+    const kept = [];
+    for (let index = 0; index < triangles.length; index += stride) {
+        const triangle = triangles[index];
+        if (triangle)
+            kept.push(triangle);
+    }
+    const positions = [];
+    const indices = [];
+    const indexByKey = new Map();
+    const pushVertex = (vertex) => {
+        // Quantise to millimetre-ish precision in model units so float noise does not defeat
+        // welding, while staying far finer than any wheel radius.
+        const key = `${vertex[0].toFixed(4)}:${vertex[1].toFixed(4)}:${vertex[2].toFixed(4)}`;
+        const existing = indexByKey.get(key);
+        if (existing !== undefined)
+            return existing;
+        const next = positions.length / 3;
+        positions.push(round4(vertex[0]), round4(vertex[1]), round4(vertex[2]));
+        indexByKey.set(key, next);
+        return next;
+    };
+    for (const triangle of kept) {
+        const a = pushVertex(triangle.a);
+        const b = pushVertex(triangle.b);
+        const c = pushVertex(triangle.c);
+        // Skip triangles that collapsed to a line or point during welding: they carry no
+        // surface and would make a raycast return a degenerate normal.
+        if (a === b || b === c || a === c)
+            continue;
+        indices.push(a, b, c);
+    }
+    if (indices.length === 0)
+        return undefined;
+    return {
+        positions,
+        indices,
+        sourceTriangleCount: triangles.length,
+        triangleCount: indices.length / 3
+    };
+}
+/** Round to 4dp. Model-space road coordinates need finer precision than `round3` gives. */
+function round4(value) {
+    return Math.round(value * 1e4) / 1e4;
+}
 function createRoadSurface(primitives) {
     const triangles = primitives.flatMap((primitive) => primitive.triangles);
     if (triangles.length === 0) {
@@ -949,6 +1060,16 @@ function traceRoadLoop(primitives, surface) {
             maxDistance = value;
     if (maxDistance <= 0)
         return [];
+    // The maximum distance belongs to the middle of a paddock/apron on real assets,
+    // not to the centre of the racing ribbon. Using it as the cost target actively
+    // rewarded the Tsukuba shortcut across the service apron. A lower quantile of all
+    // occupied cells represents the repeatable half-width of the actual road: edge
+    // cells occupy the lower tail, circuit centres the middle, and broad aprons the
+    // upper tail. The path cost below is then U-shaped around this lane-width target.
+    const occupiedDistances = Array.from(distance)
+        .filter((value, index) => road[index] === 1 && value > 0 && value < 1e8)
+        .sort((a, b) => a - b);
+    const preferredDistance = occupiedDistances[Math.min(occupiedDistances.length - 1, Math.floor(occupiedDistances.length * 0.58))] ?? Math.max(1, maxDistance * 0.2);
     const holes = roadInteriorHoles(raster, road);
     let best;
     for (const hole of holes.slice(0, 4)) {
@@ -971,7 +1092,7 @@ function traceRoadLoop(primitives, surface) {
         }
         if (seam.length === 0)
             continue;
-        const loop = shortestRoadLoop(raster, road, distance, maxDistance, seam);
+        const loop = shortestRoadLoop(raster, road, distance, preferredDistance, seam);
         if (loop.length < 24)
             continue;
         const points = loop.map((cell) => {
@@ -990,7 +1111,7 @@ function traceRoadLoop(primitives, surface) {
     // Resampling a traced loop chords across corners, and on a tight hairpin that chord can
     // clip the apex. Take the densest count that still keeps every emitted point and every
     // interpolated step on the road, rather than loosening the off-road gate.
-    for (const count of [32, 28, 24, 20]) {
+    for (const count of [72, 64, 56, 48, 40, 32, 28, 24, 20]) {
         const resampled = resampleLoop(best.points, count);
         if (resampled.length < 8)
             continue;
@@ -1014,7 +1135,7 @@ function traceRoadLoop(primitives, surface) {
  * the long way around. Cost prefers cells far from the road edge, which keeps the
  * result near the middle of the ribbon.
  */
-function shortestRoadLoop(raster, road, distance, maxDistance, seam) {
+function shortestRoadLoop(raster, road, distance, preferredDistance, seam) {
     const { width, height } = raster;
     const blocked = new Uint8Array(road.length);
     for (const cell of seam)
@@ -1047,8 +1168,13 @@ function shortestRoadLoop(raster, road, distance, maxDistance, seam) {
     const starts = [above];
     const goals = new Set([below]);
     const cellCost = (cell) => {
-        const openness = Math.min(1, distance[cell] / maxDistance);
-        return 1 + 8 * (1 - openness) ** 2;
+        const laneRatio = distance[cell] / Math.max(1e-6, preferredDistance);
+        const edgePenalty = laneRatio < 1 ? 8 * (1 - laneRatio) ** 2 : 0;
+        // A little extra width at a corner is normal; a path several lane-widths from
+        // any edge is an apron, paddock or parking surface and must not become a racing
+        // shortcut merely because it is asphalt-labelled.
+        const apronPenalty = laneRatio > 1.6 ? 5 * (laneRatio - 1.6) ** 2 : 0;
+        return 1 + edgePenalty + apronPenalty;
     };
     const best = new Float64Array(road.length).fill(Number.POSITIVE_INFINITY);
     const previous = new Int32Array(road.length).fill(-1);
@@ -1284,9 +1410,9 @@ function segmentStaysOnRoad(from, to, surface) {
     }
     return true;
 }
-function createPlayableSurfaces(primitives, bounds) {
+function createPlayableSurfaces(primitives, bounds, authoring) {
     const minX = bounds.min[0];
-    const modelToGameScale = platformerModelToGameScale(bounds);
+    const modelToGameScale = platformerModelToGameScale(bounds, authoring);
     const uniquePrimitives = uniquePlayableSurfacePrimitives(primitives);
     const candidateSurfaces = uniquePrimitives
         .map((primitive, index) => {
@@ -1304,7 +1430,7 @@ function createPlayableSurfaces(primitives, bounds) {
     });
     const selectedSurfaces = [...dedupePlayableSurfaces(candidateSurfaces)]
         .sort((a, b) => a.x - b.x)
-        .slice(0, PLATFORMER_MAX_RETAINED_MESH_SURFACES);
+        .slice(0, authoring?.maxRetainedPlayableSurfaces ?? PLATFORMER_MAX_RETAINED_MESH_SURFACES);
     const selectedBaselineTopY = selectedPlayableSurfaceBaseline(selectedSurfaces);
     const topSurfaces = selectedSurfaces.map((surface, index) => ({
         ...surface,
@@ -1413,8 +1539,8 @@ function createRacingAnchorPairs(centerline, surface) {
             }];
     });
 }
-function createPlatformerAnchorPairs(surfaces, bounds) {
-    const modelToGameScale = platformerModelToGameScale(bounds);
+function createPlatformerAnchorPairs(surfaces, bounds, authoring) {
+    const modelToGameScale = platformerModelToGameScale(bounds, authoring);
     const meshBoundSurfaces = meshBoundPlayableSurfaces(surfaces);
     const anchorSource = meshBoundSurfaces.length >= 3 ? meshBoundSurfaces : surfaces;
     const anchorSurfaces = pickPlatformerAnchorSurfaces(anchorSource
@@ -1515,11 +1641,45 @@ function pickPlatformerAnchorSurfaces(surfaces) {
     }
     return anchors;
 }
-function platformerModelToGameScale(bounds) {
+function platformerModelToGameScale(bounds, authoring) {
+    if (authoring)
+        return authoring.modelToGameScale;
     const size = boundsSize(bounds);
     const widthScale = PLATFORMER_TARGET_GAME_LENGTH / Math.max(0.001, size[0]);
     return round3(Math.min(PLATFORMER_MAX_GAME_SCALE, Math.max(PLATFORMER_MIN_GAME_SCALE, widthScale)));
 }
+function readPlatformerAuthoringMetadata(document) {
+    if (document.json.asset?.generator !== PLATFORMER_AUTHORED_WORLD_GENERATOR)
+        return undefined;
+    const value = document.json.asset.extras?.platformerGeometry;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const metadata = value;
+    const modelToGameScale = metadata.modelToGameScale;
+    const sectionModelSpan = metadata.sectionModelSpan;
+    const maxRetainedPlayableSurfaces = metadata.maxRetainedPlayableSurfaces;
+    const authoredLevelLength = metadata.authoredLevelLength;
+    const authoredCompletionSeconds = metadata.authoredCompletionSeconds;
+    if (typeof modelToGameScale !== "number" || !Number.isFinite(modelToGameScale) ||
+        modelToGameScale <= 0 || modelToGameScale > PLATFORMER_MAX_GAME_SCALE ||
+        typeof sectionModelSpan !== "number" || !Number.isFinite(sectionModelSpan) || sectionModelSpan <= 0 ||
+        typeof maxRetainedPlayableSurfaces !== "number" || !Number.isInteger(maxRetainedPlayableSurfaces) ||
+        maxRetainedPlayableSurfaces < PLATFORMER_MAX_RETAINED_MESH_SURFACES ||
+        maxRetainedPlayableSurfaces > PLATFORMER_MAX_DECLARED_RETAINED_MESH_SURFACES ||
+        (authoredLevelLength !== undefined && (typeof authoredLevelLength !== "number" || !Number.isFinite(authoredLevelLength) || authoredLevelLength <= 0)) ||
+        (authoredCompletionSeconds !== undefined && (typeof authoredCompletionSeconds !== "number" || !Number.isFinite(authoredCompletionSeconds) ||
+            authoredCompletionSeconds < 30 || authoredCompletionSeconds > 300)))
+        return undefined;
+    return {
+        modelToGameScale: round3(modelToGameScale),
+        sectionModelSpan: round3(sectionModelSpan),
+        maxRetainedPlayableSurfaces,
+        ...(typeof authoredLevelLength === "number" ? { authoredLevelLength: round3(authoredLevelLength) } : {}),
+        ...(typeof authoredCompletionSeconds === "number" ? {
+            authoredCompletionSeconds: round3(authoredCompletionSeconds)
+        } : {})
+    };
+}
 function platformerCharacterFootprintWidth(options, projectDir) {
     if (options.characterFootprintWidth !== undefined)
         return options.characterFootprintWidth;