@plasius/gpu-world-generator 0.0.10 → 0.0.12

package/dist/index.js

@@ -1784,6 +1784,751 @@ function createMeshBuilder(sizeOrOptions = 1) {
     }
   };
 }
+
+// src/worker.ts
+var worldGeneratorDebugOwner = "world-generator";
+var worldGeneratorWorkerQueueClass = "voxel";
+var defaultWorldGeneratorWorkerProfile = "streaming";
+var worldGeneratorRepresentationBands = Object.freeze([
+  "near",
+  "mid",
+  "far",
+  "horizon"
+]);
+var worldGeneratorRepresentationOutputs = Object.freeze([
+  "liveGeometry",
+  "simplifiedGeometry",
+  "rtProxy",
+  "mergedProxy",
+  "horizonShell"
+]);
+var worldGeneratorRepresentationBandPriorityHints = Object.freeze({
+  near: 400,
+  mid: 300,
+  far: 200,
+  horizon: 100
+});
+function assertWorldGeneratorIdentifier(name, value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${name} must be a non-empty string.`);
+  }
+  return value.trim();
+}
+function normalizeWorldGeneratorImportance(name, value) {
+  if (value === "medium" || value === "high" || value === "critical") {
+    return value;
+  }
+  throw new Error(`${name} must be one of: medium, high, critical.`);
+}
+function buildWorldGeneratorRepresentationDescriptor(options) {
+  return Object.freeze({
+    id: `${options.chunkId}.${options.band}.${options.output}`,
+    chunkId: options.chunkId,
+    profile: options.profile,
+    band: options.band,
+    output: options.output,
+    rasterMode: options.rasterMode,
+    rtParticipation: options.rtParticipation,
+    shadowRelevance: options.shadowRelevance,
+    refreshCadence: Object.freeze({
+      kind: options.refreshCadence.kind,
+      divisor: options.refreshCadence.divisor
+    }),
+    preservesChunkIdentity: options.preservesChunkIdentity,
+    sourceChunkIds: Object.freeze([options.chunkId]),
+    sourceJobKeys: Object.freeze([...options.sourceJobKeys]),
+    suggestedAllocationIds: Object.freeze([...options.suggestedAllocationIds]),
+    scheduling: Object.freeze({
+      owner: "renderer",
+      queueClass: worldGeneratorWorkerQueueClass,
+      priorityHint: worldGeneratorRepresentationBandPriorityHints[options.band],
+      gameplayImportance: options.gameplayImportance,
+      representationBand: options.band
+    })
+  });
+}
+function buildBudgetLevels(jobType, queueClass, levels) {
+  return Object.freeze(
+    levels.map(
+      (level) => Object.freeze({
+        id: level.id,
+        estimatedCostMs: level.estimatedCostMs,
+        config: Object.freeze({
+          maxDispatchesPerFrame: level.config.maxDispatchesPerFrame,
+          maxJobsPerDispatch: level.config.maxJobsPerDispatch,
+          cadenceDivisor: level.config.cadenceDivisor,
+          workgroupScale: level.config.workgroupScale,
+          maxQueueDepth: level.config.maxQueueDepth,
+          metadata: Object.freeze({
+            owner: worldGeneratorDebugOwner,
+            queueClass,
+            jobType,
+            quality: level.id
+          })
+        })
+      })
+    )
+  );
+}
+var worldGeneratorWorkerProfileSpecs = {
+  streaming: {
+    description: "Runtime chunk generation DAG for fractal prepass, terrain synthesis, voxel materialization, mesh build, and tile bake.",
+    suggestedAllocationIds: [
+      "world.chunk.field.scratch",
+      "world.chunk.height.buffer",
+      "world.chunk.voxel.buffer",
+      "world.chunk.mesh.buffer"
+    ],
+    jobs: {
+      fractalPrepass: {
+        priority: 4,
+        dependencies: [],
+        domain: "custom",
+        authority: "authoritative",
+        importance: "high",
+        levels: [
+          {
+            id: "fixed",
+            estimatedCostMs: 0.6,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 32
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.chunk.field.scratch"]
+      },
+      fieldSynthesis: {
+        priority: 4,
+        dependencies: [],
+        domain: "custom",
+        authority: "authoritative",
+        importance: "critical",
+        levels: [
+          {
+            id: "fixed",
+            estimatedCostMs: 0.9,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 2,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 48
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.chunk.field.scratch"]
+      },
+      terrainSynthesis: {
+        priority: 5,
+        dependencies: ["fractalPrepass", "fieldSynthesis"],
+        domain: "custom",
+        authority: "authoritative",
+        importance: "critical",
+        levels: [
+          {
+            id: "fixed",
+            estimatedCostMs: 1.4,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 32
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.chunk.height.buffer"]
+      },
+      voxelMaterialize: {
+        priority: 3,
+        dependencies: ["terrainSynthesis"],
+        domain: "custom",
+        authority: "non-authoritative-simulation",
+        importance: "high",
+        levels: [
+          {
+            id: "low",
+            estimatedCostMs: 0.8,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 2,
+              workgroupScale: 0.6,
+              maxQueueDepth: 24
+            }
+          },
+          {
+            id: "medium",
+            estimatedCostMs: 1.2,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 2,
+              cadenceDivisor: 1,
+              workgroupScale: 0.8,
+              maxQueueDepth: 32
+            }
+          },
+          {
+            id: "high",
+            estimatedCostMs: 1.8,
+            config: {
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 2,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 40
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.chunk.voxel.buffer"]
+      },
+      meshBuild: {
+        priority: 2,
+        dependencies: ["terrainSynthesis", "voxelMaterialize"],
+        domain: "geometry",
+        authority: "visual",
+        importance: "high",
+        levels: [
+          {
+            id: "low",
+            estimatedCostMs: 0.7,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 2,
+              workgroupScale: 0.6,
+              maxQueueDepth: 16
+            }
+          },
+          {
+            id: "medium",
+            estimatedCostMs: 1.1,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 1,
+              workgroupScale: 0.8,
+              maxQueueDepth: 24
+            }
+          },
+          {
+            id: "high",
+            estimatedCostMs: 1.6,
+            config: {
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 2,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 32
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.chunk.mesh.buffer"]
+      },
+      tileBake: {
+        priority: 2,
+        dependencies: ["terrainSynthesis"],
+        domain: "textures",
+        authority: "non-authoritative-simulation",
+        importance: "medium",
+        levels: [
+          {
+            id: "low",
+            estimatedCostMs: 0.6,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 3,
+              workgroupScale: 0.5,
+              maxQueueDepth: 16
+            }
+          },
+          {
+            id: "medium",
+            estimatedCostMs: 0.9,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 2,
+              workgroupScale: 0.75,
+              maxQueueDepth: 24
+            }
+          },
+          {
+            id: "high",
+            estimatedCostMs: 1.3,
+            config: {
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 2,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 32
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.chunk.height.buffer"]
+      }
+    }
+  },
+  bake: {
+    description: "Offline tile bake DAG for terrain generation, voxel materialization, mesh build, and asset serialization.",
+    suggestedAllocationIds: [
+      "world.bake.field.scratch",
+      "world.bake.height.buffer",
+      "world.bake.mesh.buffer",
+      "world.bake.asset.binary"
+    ],
+    jobs: {
+      fractalPrepass: {
+        priority: 4,
+        dependencies: [],
+        domain: "custom",
+        authority: "authoritative",
+        importance: "high",
+        levels: [
+          {
+            id: "fixed",
+            estimatedCostMs: 0.7,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 32
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.bake.field.scratch"]
+      },
+      fieldSynthesis: {
+        priority: 4,
+        dependencies: [],
+        domain: "custom",
+        authority: "authoritative",
+        importance: "critical",
+        levels: [
+          {
+            id: "fixed",
+            estimatedCostMs: 1,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 2,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 48
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.bake.field.scratch"]
+      },
+      terrainSynthesis: {
+        priority: 5,
+        dependencies: ["fractalPrepass", "fieldSynthesis"],
+        domain: "custom",
+        authority: "authoritative",
+        importance: "critical",
+        levels: [
+          {
+            id: "fixed",
+            estimatedCostMs: 1.6,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 32
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.bake.height.buffer"]
+      },
+      voxelMaterialize: {
+        priority: 3,
+        dependencies: ["terrainSynthesis"],
+        domain: "custom",
+        authority: "non-authoritative-simulation",
+        importance: "high",
+        levels: [
+          {
+            id: "low",
+            estimatedCostMs: 0.9,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 2,
+              workgroupScale: 0.6,
+              maxQueueDepth: 24
+            }
+          },
+          {
+            id: "medium",
+            estimatedCostMs: 1.4,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 2,
+              cadenceDivisor: 1,
+              workgroupScale: 0.8,
+              maxQueueDepth: 32
+            }
+          },
+          {
+            id: "high",
+            estimatedCostMs: 2,
+            config: {
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 2,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 48
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.bake.height.buffer"]
+      },
+      meshBuild: {
+        priority: 2,
+        dependencies: ["terrainSynthesis", "voxelMaterialize"],
+        domain: "geometry",
+        authority: "visual",
+        importance: "high",
+        levels: [
+          {
+            id: "low",
+            estimatedCostMs: 0.9,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 2,
+              workgroupScale: 0.6,
+              maxQueueDepth: 16
+            }
+          },
+          {
+            id: "medium",
+            estimatedCostMs: 1.3,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 1,
+              workgroupScale: 0.8,
+              maxQueueDepth: 24
+            }
+          },
+          {
+            id: "high",
+            estimatedCostMs: 1.9,
+            config: {
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 2,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 32
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.bake.mesh.buffer"]
+      },
+      tileBake: {
+        priority: 2,
+        dependencies: ["terrainSynthesis"],
+        domain: "textures",
+        authority: "non-authoritative-simulation",
+        importance: "medium",
+        levels: [
+          {
+            id: "low",
+            estimatedCostMs: 0.8,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 3,
+              workgroupScale: 0.5,
+              maxQueueDepth: 16
+            }
+          },
+          {
+            id: "medium",
+            estimatedCostMs: 1.1,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 2,
+              workgroupScale: 0.75,
+              maxQueueDepth: 24
+            }
+          },
+          {
+            id: "high",
+            estimatedCostMs: 1.5,
+            config: {
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 2,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 32
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.bake.height.buffer"]
+      },
+      assetSerialize: {
+        priority: 1,
+        dependencies: ["meshBuild", "tileBake"],
+        domain: "custom",
+        authority: "non-authoritative-simulation",
+        importance: "medium",
+        levels: [
+          {
+            id: "low",
+            estimatedCostMs: 0.4,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 4,
+              workgroupScale: 0.5,
+              maxQueueDepth: 8
+            }
+          },
+          {
+            id: "medium",
+            estimatedCostMs: 0.7,
+            config: {
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 1,
+              cadenceDivisor: 2,
+              workgroupScale: 0.75,
+              maxQueueDepth: 12
+            }
+          },
+          {
+            id: "high",
+            estimatedCostMs: 1,
+            config: {
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 2,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 16
+            }
+          }
+        ],
+        suggestedAllocationIds: ["world.bake.asset.binary"]
+      }
+    }
+  }
+};
+function buildWorldGeneratorWorkerProfile(name, spec) {
+  return Object.freeze({
+    name,
+    description: spec.description,
+    jobs: Object.freeze(Object.keys(spec.jobs))
+  });
+}
+function buildWorldGeneratorWorkerManifestJob(profileName, jobName, spec) {
+  const label = `world-generator.${profileName}.${jobName}`;
+  return Object.freeze({
+    key: jobName,
+    label,
+    worker: Object.freeze({
+      jobType: label,
+      queueClass: worldGeneratorWorkerQueueClass,
+      priority: spec.priority,
+      dependencies: Object.freeze(
+        spec.dependencies.map(
+          (dependency) => `world-generator.${profileName}.${dependency}`
+        )
+      ),
+      schedulerMode: "dag"
+    }),
+    performance: Object.freeze({
+      id: label,
+      jobType: label,
+      queueClass: worldGeneratorWorkerQueueClass,
+      domain: spec.domain,
+      authority: spec.authority,
+      importance: spec.importance,
+      levels: buildBudgetLevels(
+        label,
+        worldGeneratorWorkerQueueClass,
+        spec.levels
+      )
+    }),
+    debug: Object.freeze({
+      owner: worldGeneratorDebugOwner,
+      queueClass: worldGeneratorWorkerQueueClass,
+      jobType: label,
+      tags: Object.freeze(["world-generator", profileName, jobName, spec.domain]),
+      suggestedAllocationIds: Object.freeze([...spec.suggestedAllocationIds])
+    })
+  });
+}
+function buildWorldGeneratorWorkerManifest(name, spec) {
+  return Object.freeze({
+    schemaVersion: 1,
+    owner: worldGeneratorDebugOwner,
+    profile: name,
+    description: spec.description,
+    queueClass: worldGeneratorWorkerQueueClass,
+    schedulerMode: "dag",
+    suggestedAllocationIds: Object.freeze([...spec.suggestedAllocationIds]),
+    jobs: Object.freeze(
+      Object.entries(spec.jobs).map(
+        ([jobName, jobSpec]) => buildWorldGeneratorWorkerManifestJob(name, jobName, jobSpec)
+      )
+    )
+  });
+}
+var worldGeneratorWorkerProfiles = Object.freeze(
+  Object.fromEntries(
+    Object.entries(worldGeneratorWorkerProfileSpecs).map(([name, spec]) => [
+      name,
+      buildWorldGeneratorWorkerProfile(
+        name,
+        spec
+      )
+    ])
+  )
+);
+var worldGeneratorWorkerProfileNames = Object.freeze(
+  Object.keys(worldGeneratorWorkerProfiles)
+);
+var worldGeneratorWorkerManifests = Object.freeze(
+  Object.fromEntries(
+    Object.entries(worldGeneratorWorkerProfileSpecs).map(([name, spec]) => [
+      name,
+      buildWorldGeneratorWorkerManifest(
+        name,
+        spec
+      )
+    ])
+  )
+);
+function getWorldGeneratorWorkerProfile(name = defaultWorldGeneratorWorkerProfile) {
+  const profile = worldGeneratorWorkerProfiles[name];
+  if (!profile) {
+    const available = worldGeneratorWorkerProfileNames.join(", ");
+    throw new Error(
+      `Unknown world-generator worker profile "${name}". Available: ${available}.`
+    );
+  }
+  return profile;
+}
+function getWorldGeneratorWorkerManifest(name = defaultWorldGeneratorWorkerProfile) {
+  const manifest = worldGeneratorWorkerManifests[name];
+  if (!manifest) {
+    const available = worldGeneratorWorkerProfileNames.join(", ");
+    throw new Error(
+      `Unknown world-generator worker profile "${name}". Available: ${available}.`
+    );
+  }
+  return manifest;
+}
+function createWorldGeneratorRepresentationPlan(options) {
+  const profile = options.profile ?? defaultWorldGeneratorWorkerProfile;
+  const spec = worldGeneratorWorkerProfileSpecs[profile];
+  if (!spec) {
+    const available = worldGeneratorWorkerProfileNames.join(", ");
+    throw new Error(
+      `Unknown world-generator worker profile "${profile}". Available: ${available}.`
+    );
+  }
+  const chunkId = assertWorldGeneratorIdentifier("chunkId", options.chunkId);
+  const gameplayImportance = normalizeWorldGeneratorImportance(
+    "gameplayImportance",
+    options.gameplayImportance ?? "high"
+  );
+  const highValueAllocations = spec.suggestedAllocationIds;
+  const farFieldAllocations = spec.suggestedAllocationIds.filter(
+    (allocationId) => allocationId.includes("mesh") || allocationId.includes("asset") || allocationId.includes("tile")
+  );
+  const bakeSourceJobKeys = profile === "bake" ? ["meshBuild", "tileBake", "assetSerialize"] : ["meshBuild", "tileBake"];
+  const representations = Object.freeze([
+    buildWorldGeneratorRepresentationDescriptor({
+      profile,
+      chunkId,
+      band: "near",
+      output: "liveGeometry",
+      rasterMode: "full-live",
+      rtParticipation: "full",
+      shadowRelevance: "ray-traced-primary",
+      refreshCadence: { kind: "per-frame", divisor: 1 },
+      preservesChunkIdentity: true,
+      sourceJobKeys: ["meshBuild"],
+      gameplayImportance: gameplayImportance === "medium" ? "high" : gameplayImportance,
+      suggestedAllocationIds: highValueAllocations
+    }),
+    buildWorldGeneratorRepresentationDescriptor({
+      profile,
+      chunkId,
+      band: "mid",
+      output: "simplifiedGeometry",
+      rasterMode: "simplified-live",
+      rtParticipation: "selective",
+      shadowRelevance: "selective-raster",
+      refreshCadence: { kind: "interval", divisor: 2 },
+      preservesChunkIdentity: true,
+      sourceJobKeys: ["meshBuild"],
+      gameplayImportance,
+      suggestedAllocationIds: highValueAllocations
+    }),
+    buildWorldGeneratorRepresentationDescriptor({
+      profile,
+      chunkId,
+      band: "mid",
+      output: "rtProxy",
+      rasterMode: "not-rendered",
+      rtParticipation: "proxy",
+      shadowRelevance: "selective-raster",
+      refreshCadence: { kind: "interval", divisor: 2 },
+      preservesChunkIdentity: true,
+      sourceJobKeys: ["meshBuild", "tileBake"],
+      gameplayImportance,
+      suggestedAllocationIds: highValueAllocations
+    }),
+    buildWorldGeneratorRepresentationDescriptor({
+      profile,
+      chunkId,
+      band: "far",
+      output: "mergedProxy",
+      rasterMode: "proxy",
+      rtParticipation: "proxy",
+      shadowRelevance: "proxy-caster",
+      refreshCadence: { kind: "interval", divisor: 8 },
+      preservesChunkIdentity: true,
+      sourceJobKeys: bakeSourceJobKeys,
+      gameplayImportance: "medium",
+      suggestedAllocationIds: farFieldAllocations.length > 0 ? farFieldAllocations : highValueAllocations
+    }),
+    buildWorldGeneratorRepresentationDescriptor({
+      profile,
+      chunkId,
+      band: "horizon",
+      output: "horizonShell",
+      rasterMode: "horizon-shell",
+      rtParticipation: "disabled",
+      shadowRelevance: "baked-impression",
+      refreshCadence: { kind: "interval", divisor: 60 },
+      preservesChunkIdentity: true,
+      sourceJobKeys: profile === "bake" ? ["tileBake", "assetSerialize"] : ["tileBake"],
+      gameplayImportance: "medium",
+      suggestedAllocationIds: farFieldAllocations.length > 0 ? farFieldAllocations : highValueAllocations
+    })
+  ]);
+  return Object.freeze({
+    schemaVersion: 1,
+    owner: worldGeneratorDebugOwner,
+    profile,
+    chunkId,
+    representations,
+    bands: Object.freeze(
+      [...new Set(representations.map((representation) => representation.band))]
+    )
+  });
+}
 export {
   DEFAULT_TILE_SIZE_WORLD,
   FIELD_DOWNWARD_MAX,
@@ -1811,13 +2556,17 @@ export {
   createFractalPrepassRunner,
   createMeshBuilder,
   createPerfMonitor,
+  createWorldGeneratorRepresentationPlan,
   defaultFieldParams,
   defaultFractalMandelSettings,
+  defaultWorldGeneratorWorkerProfile,
   encodeTerrainParams,
   fieldWgslUrl,
   fractalPrepassWgslUrl,
   generateHexGrid,
   generateTemperateMixedForest,
+  getWorldGeneratorWorkerManifest,
+  getWorldGeneratorWorkerProfile,
   hexAreaFromSide,
   hexSideFromArea,
   loadFieldWgsl,
@@ -1843,6 +2592,13 @@ export {
   tileKeyFromWorldPosition,
   tileKeyToString,
   unpackTerrain,
-  validateTileAssetPayload
+  validateTileAssetPayload,
+  worldGeneratorDebugOwner,
+  worldGeneratorRepresentationBands,
+  worldGeneratorRepresentationOutputs,
+  worldGeneratorWorkerManifests,
+  worldGeneratorWorkerProfileNames,
+  worldGeneratorWorkerProfiles,
+  worldGeneratorWorkerQueueClass
 };
 //# sourceMappingURL=index.js.map