@forgeax/engine-render 0.1.6 → 0.1.7

package/dist/construct-renderer.mjs

@@ -1,5 +1,5 @@
-import { getTransparentSortConfig, TRANSPARENT_SORT_MODE_DISTANCE, GlyphText, TRANSPARENT_SORT_MODE_LAYER_Z, TRANSPARENT_SORT_MODE_LAYER_Y, TRANSPARENT_SORT_MODE_LAYER_YZ } from './chunk-QC4VW3XJ.mjs';
-import { MeshFilter, MeshRenderer, Instances, Layer, Visibility, Camera, DirectionalLight, PointLight, PointLightShadow, SpotLight, Skylight, SkyboxBackground, PostProcessParams, DEFAULT_STANDARD_PROFILE, RENDER_PHASE_CATALOG, DEFAULT_CLUSTER_GRID, STANDARD_TONEMAP_FEATURE_ID, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, resolveVisibility, CLUSTER_GRID_STRIDE_U32, LIGHT_INDEX_LIST_CAPACITY, resolveStandardLane, CAMERA_PROJECTION_ORTHOGRAPHIC, bloomEnabledFromF32, antialiasFromF32, tonemapFromF32, cameraProjectionFromF32, tonemapToU32, MAX_LIGHTS } from './chunk-SCRSAK5B.mjs';
+import { getTransparentSortConfig, TRANSPARENT_SORT_MODE_DISTANCE, GlyphText, TRANSPARENT_SORT_MODE_LAYER_Z, TRANSPARENT_SORT_MODE_LAYER_Y, TRANSPARENT_SORT_MODE_LAYER_YZ, selectActiveCameraIndex, getActiveCamera } from './chunk-HCOGPHKS.mjs';
+import { MeshFilter, MeshRenderer, Instances, Layer, Visibility, Camera, DirectionalLight, PointLight, PointLightShadow, SpotLight, Skylight, SkyboxBackground, PostProcessParams, RendererContractFailureError, RendererOperationError, DEFAULT_STANDARD_PROFILE, RENDER_PHASE_CATALOG, DEFAULT_CLUSTER_GRID, FrameReceiptStaleError, RenderFeatureStageFailedError, RenderFeatureCapabilityMissingError, RenderFeatureRegistrationConflictError, LifecycleConstructionError, STANDARD_TONEMAP_FEATURE_ID, PointsLinesMaterialUnsupportedError, admitPointsLines, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, ObservationUnavailableError, resolveVisibility, Points, Lines, SortKey, SkinMaterialMismatchError, MaterialSkinAttrMissingError, pointShapeFromU32, CLUSTER_GRID_STRIDE_U32, LIGHT_INDEX_LIST_CAPACITY, RenderFeaturePreparationFailedError, PointShadowAtlasUninitializedError, PointShadowAtlasBoundsViolationError, EquirectProjectionFailedError, HdrpLightBudgetExceededError, resolveStandardLane, CAMERA_PROJECTION_ORTHOGRAPHIC, PointsLinesPrepareFailedError, bloomEnabledFromF32, antialiasFromF32, tonemapFromF32, cameraProjectionFromF32, ShadowInvalidConfigError, tonemapToU32, MAX_LIGHTS, HdrpIndexListOverflowError, RenderFeaturePreparedStateMismatchError, RenderFeatureDrawRecordingFailedError, HdrpDeferredCapsInsufficientError, SkinPaletteOverflowError, VideoUploadUnsupportedError, VertexColorVariantConflictError } from './chunk-YEJIUW7D.mjs';
 import { SpriteInstances, SpriteRegionOverride, TileLayer, decodeSortScope, Tilemap, SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-CQXZC5XI.mjs';
 import { AssetRegistry, DynamicTextureStore, adaptDynamicTextureDevice, getOrCreateMipmapPipeline, blitMipmapsSync, numMipLevels, HANDLE_CUBE, HANDLE_TRIANGLE, HANDLE_QUAD, HANDLE_SPHERE, HANDLE_NINESLICE_QUAD, BuiltinAssetRegistry, resolveAssetHandle, walkMaterialPassesOverSharedRefs, resolveTilesetRuntime, MeshSsboCeilingReachedError, MeshSsboCapacityExceededError } from '@forgeax/engine-assets-runtime';
 import { audioLoader } from '@forgeax/engine-audio-webaudio';
@@ -2261,422 +2261,6 @@ var RenderRecoveryError = class extends Error {
     this.detail = detail;
   }
 };
-
-// src/errors/render.ts
-var LifecycleConstructionError = class extends Error {
-  code = "lifecycle-construction-failed";
-  expected = "all DeviceScope resources establish and terminate in order";
-  hint = "inspect detail and cleanupFailures, then recover or rebuild the DeviceScope";
-  detail;
-  constructor(detail) {
-    super(`lifecycle-construction-failed: ${detail.resourceKind} lifecycle transaction failed`);
-    this.name = "LifecycleConstructionError";
-    this.detail = detail;
-  }
-};
-var ShadowInvalidConfigError = class extends Error {
-  code = "shadow-invalid-config";
-  expected;
-  hint;
-  detail;
-  constructor(field, value, min, maxOrComparator) {
-    const isComparator = maxOrComparator === ">" || maxOrComparator === ">=";
-    const max = !isComparator && typeof maxOrComparator === "number" ? maxOrComparator : void 0;
-    const comparator = isComparator ? maxOrComparator : ">=";
-    const isInteger = field === "cascadeCount" || field === "pcfKernelSize";
-    const isOdd = field === "pcfKernelSize";
-    const hint = max !== void 0 ? isInteger ? `set ${field} to an integer in [${min}, ${max}]; got ${value}` : `set ${field} to a value in [${min}, ${max}]; got ${value}` : isOdd ? `set ${field} to an odd integer ${comparator} ${min}; got ${value}` : `set ${field} to a value ${comparator} ${min}; got ${value}`;
-    const expected = max !== void 0 ? `${field} in [${min}, ${max}]` : `${field} ${comparator} ${min}`;
-    super(
-      max !== void 0 ? `shadow component .${field} must be in [${min}, ${max}], got ${value}` : `shadow component .${field} must be ${comparator} ${min}, got ${value}`
-    );
-    this.name = "ShadowInvalidConfigError";
-    this.hint = hint;
-    this.expected = expected;
-    this.detail = { field, value, min, ...max !== void 0 ? { max } : {} };
-  }
-};
-var EquirectProjectionFailedError = class extends Error {
-  code = "equirect-projection-failed";
-  expected;
-  hint;
-  detail;
-  constructor(handle) {
-    const expected = `equirect handle ${handle} projects to a GPU cubemap + IBL precompute`;
-    const hint = `equirect handle ${handle} referenced by Skylight/SkyboxBackground failed projection; declare Skylight{equirect} with a valid HDR equirect source and check device.caps.rgba16floatRenderable. The projection is internal (no user upload call); the record arm does not retry`;
-    super(`equirect handle ${handle} cubemap projection failed`);
-    this.name = "EquirectProjectionFailedError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { handle };
-  }
-};
-var HdrpLightBudgetExceededError = class extends Error {
-  code = "hdrp-light-budget-exceeded";
-  expected;
-  hint;
-  detail;
-  constructor(actual, budget) {
-    const expected = `light count <= ${budget}`;
-    const hint = `${actual} lights exceed HDRP budget ${budget}; truncating to 256. Reduce light count or wait for OOS-hdrp-larger-budget`;
-    super(`HDRP light budget exceeded: ${actual} > ${budget}`);
-    this.name = "HdrpLightBudgetExceededError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { actual, budget };
-  }
-};
-var HdrpIndexListOverflowError = class extends Error {
-  code = "hdrp-index-list-overflow";
-  expected;
-  hint;
-  detail;
-  constructor(actual, capacity) {
-    const expected = `light index list entries <= ${capacity}`;
-    const hint = `cluster binner overflow: writeCount ${actual} exceeds capacity ${capacity}; reduce lights, shrink cluster grid, or increase LIGHT_INDEX_LIST_CAPACITY`;
-    super(`HDRP index list overflow: ${actual} > ${capacity}`);
-    this.name = "HdrpIndexListOverflowError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { actual, capacity };
-  }
-};
-var HdrpDeferredCapsInsufficientError = class extends Error {
-  code = "hdrp-deferred-caps-insufficient";
-  expected;
-  hint;
-  detail;
-  constructor(actual) {
-    const _expected = 4;
-    const _expectedStr = `maxColorAttachments >= ${_expected}`;
-    const hint = `WebGPU maxColorAttachments = ${actual} (need >= ${_expected}). Upgrade browser to latest Chrome/Edge/Safari, or use URP (forgeax::urp) instead of HDRP.`;
-    super(
-      `HDRP deferred caps insufficient: maxColorAttachments = ${actual} (need >= ${_expected})`
-    );
-    this.name = "HdrpDeferredCapsInsufficientError";
-    this.expected = _expectedStr;
-    this.hint = hint;
-    this.detail = { actual, expected: _expected };
-  }
-};
-var PointShadowAtlasUninitializedError = class extends Error {
-  code = "point-shadow-atlas-uninitialized";
-  expected;
-  hint;
-  constructor() {
-    const expected = "ShadowAtlas.ensure() invoked before faceView()";
-    const hint = "Gate faceView on isAllocated() or call ensure() once in the per-frame extract step before iterating face views";
-    super("ShadowAtlas.faceView called before ensure(); the cube_array texture is not allocated");
-    this.name = "PointShadowAtlasUninitializedError";
-    this.expected = expected;
-    this.hint = hint;
-  }
-};
-var PointShadowAtlasBoundsViolationError = class extends Error {
-  code = "point-shadow-atlas-bounds-violation";
-  expected;
-  hint;
-  detail;
-  constructor(axis, value, max) {
-    const expected = `0 <= ${axis} < ${max}`;
-    const hint = axis === "layer" ? `clamp PointLight.shadowAtlasLayer to [0, ${max}); the cap on layers equals PointLightShadow cardinality (4)` : `clamp face index to [0, ${max}); cube faces are indexed 0..5 in +X/-X/+Y/-Y/+Z/-Z order`;
-    super(`ShadowAtlas.faceView ${axis} out of range: ${value} (must be in [0, ${max}))`);
-    this.name = "PointShadowAtlasBoundsViolationError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { axis, value, max };
-  }
-};
-var VideoUploadUnsupportedError = class extends Error {
-  code = "video-upload-unsupported";
-  expected;
-  hint;
-  constructor() {
-    const expected = "at least one video upload path available: a host HTMLVideoElement (general copyExternalImageToTexture path) or GPUExternalTexture capability (high-perf path)";
-    const hint = "this backend exposes no usable video upload path; render a static texture instead, or switch to a WebGPU backend that supports video texture upload";
-    super("video upload unsupported \u2014 no general or high-perf path available");
-    this.name = "VideoUploadUnsupportedError";
-    this.expected = expected;
-    this.hint = hint;
-  }
-};
-var VertexColorVariantConflictError = class extends Error {
-  code = "vertex-color-variant-conflict";
-  expected;
-  hint;
-  detail;
-  constructor(authoredValue, projected) {
-    const expected = `VERTEX_COLOR_AVAILABLE=${projected ? "true" : "false"}`;
-    const hint = "derive the shader variant from the mesh VertexLayoutProjection; COLOR_0 presence is a geometry fact";
-    super(`authored vertex-color variant ${authoredValue} disagrees with projected ${expected}`);
-    this.name = "VertexColorVariantConflictError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { authored: true, authoredValue, projected };
-  }
-};
-var SkinPaletteOverflowError = class extends Error {
-  code = "skin-palette-overflow";
-  expected;
-  hint;
-  detail;
-  constructor(requestedBytes, limit) {
-    const expected = `skinned joint palette (${requestedBytes} B) fits within device.limits.maxStorageBufferBindingSize (${limit} B)`;
-    const hint = "palette buffer exceeds device maxStorageBufferBindingSize; reduce skinned entity count or split into multiple palette buffers (OOS-skin-palette-batch)";
-    super(`skin palette buffer needs ${requestedBytes} B, exceeds device limit ${limit} B`);
-    this.name = "SkinPaletteOverflowError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { requestedBytes, limit };
-  }
-};
-var SkinMaterialMismatchError = class extends Error {
-  code = "skin-material-mismatch";
-  expected;
-  hint;
-  detail;
-  constructor(entity, actualShader) {
-    const expected = "Skin entity's first material program module === 'forgeax::pbr-skin'";
-    const hint = `entity ${entity} has Skin but the first material program module is ${actualShader ?? "<empty>"}; load the mesh via the gltf importer (cooker auto-routes 'forgeax::pbr-skin' for skinned primitives), or remove the Skin component to render the entity unskinned with Materials.standard / Materials.unlit`;
-    super(
-      `Skin / material mismatch on entity ${entity}: expected forgeax::pbr-skin, got ${actualShader ?? "<empty>"}`
-    );
-    this.name = "SkinMaterialMismatchError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { entity, actualShader };
-  }
-};
-var MaterialSkinAttrMissingError = class extends Error {
-  code = "material-skin-attr-missing";
-  expected;
-  hint;
-  detail;
-  constructor(entity, missing2) {
-    const expected = "pbr-skin material requires mesh.attributes.skinIndex + skinWeight";
-    const hint = `entity ${entity} uses forgeax::pbr-skin but its MeshAsset is missing ${missing2}; switch the entity to a skinned glTF mesh authored with JOINTS_0 + WEIGHTS_0, or change the material to a non-skin shader via Materials.standard / Materials.unlit`;
-    super(
-      `material/skin attribute mismatch on entity ${entity}: pbr-skin material with mesh missing ${missing2}`
-    );
-    this.name = "MaterialSkinAttrMissingError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { entity, missing: missing2 };
-  }
-};
-var renderFeatureRecoveryHintByRecovery = {
-  "next-frame": (featureIdentity, stage) => `correct '${featureIdentity}' ${stage} data and retry on the next frame`,
-  "renderer-recover": (featureIdentity, _stage) => `wait for renderer recovery before retrying '${featureIdentity}'`,
-  registration: (featureIdentity, _stage) => `correct '${featureIdentity}' registration before retrying`
-};
-var RenderFeatureRegistrationConflictError = class extends Error {
-  code = "render-feature-registration-conflict";
-  expected;
-  hint;
-  detail;
-  constructor(featureIdentity, order, conflictingOrder) {
-    const expected = `feature identity '${featureIdentity}' is unique`;
-    const hint = `rename '${featureIdentity}' or remove the duplicate feature before registration`;
-    super(`render feature registration conflict for '${featureIdentity}'`);
-    this.name = "RenderFeatureRegistrationConflictError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { featureIdentity, order, conflictingOrder };
-  }
-};
-var RenderFeatureStageFailedError = class extends Error {
-  code = "render-feature-stage-failed";
-  expected;
-  hint;
-  detail;
-  constructor(featureIdentity, order, stage, recovery) {
-    const expected = `feature '${featureIdentity}' completes its ${stage} stage without an error`;
-    const hint = renderFeatureRecoveryHintByRecovery[recovery](featureIdentity, stage);
-    super(`render feature '${featureIdentity}' failed during ${stage}`);
-    this.name = "RenderFeatureStageFailedError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { featureIdentity, order, stage, recovery };
-  }
-};
-var RenderFeatureCapabilityMissingError = class extends Error {
-  code = "render-feature-capability-missing";
-  expected;
-  hint;
-  detail;
-  constructor(featureIdentity, order, capability) {
-    const expected = `device capability '${capability}' is available for feature '${featureIdentity}'`;
-    const hint = `disable '${featureIdentity}' or use a device with '${capability}' capability`;
-    super(`render feature '${featureIdentity}' requires missing capability '${capability}'`);
-    this.name = "RenderFeatureCapabilityMissingError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { featureIdentity, order, capability };
-  }
-};
-var RenderFeaturePreparationFailedError = class extends Error {
-  code = "render-feature-preparation-failed";
-  expected;
-  hint;
-  detail;
-  constructor(featureIdentity, order, operation, resourceKind, resourceName, reason, recovery) {
-    const expected = `${resourceKind} '${resourceName}' is prepared during ${operation}`;
-    const hint = `repair '${resourceName}' and retry feature '${featureIdentity}' on ${recovery}`;
-    super(`render feature '${featureIdentity}' preparation failed for '${resourceName}'`);
-    this.name = "RenderFeaturePreparationFailedError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = {
-      featureIdentity,
-      order,
-      stage: "prepare",
-      operation,
-      resourceKind,
-      resourceName,
-      reason,
-      recovery
-    };
-  }
-};
-var RenderFeaturePreparedStateMismatchError = class extends Error {
-  code = "render-feature-prepared-state-mismatch";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    const expected = `${detail.resourceKind} state is compatible for '${detail.operation}'`;
-    const hint = `repair '${detail.reason}' for feature '${detail.featureIdentity}' and retry`;
-    super(`render feature '${detail.featureIdentity}' prepared state mismatch`);
-    this.name = "RenderFeaturePreparedStateMismatchError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = detail;
-  }
-};
-var RenderFeatureDrawRecordingFailedError = class extends Error {
-  code = "render-feature-draw-recording-failed";
-  expected;
-  hint;
-  detail;
-  constructor(featureIdentity, order, operation, resourceKind, reason, backendReason, recovery) {
-    const expected = `${resourceKind} recording succeeds for '${operation}'`;
-    const hint = `repair '${reason}' and retry feature '${featureIdentity}' after ${recovery}`;
-    super(`render feature '${featureIdentity}' draw recording failed`);
-    this.name = "RenderFeatureDrawRecordingFailedError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = {
-      featureIdentity,
-      order,
-      stage: "record",
-      operation,
-      resourceKind,
-      reason,
-      backendReason,
-      recovery
-    };
-  }
-};
-var ObservationUnavailableError = class extends Error {
-  code = "observation-unavailable";
-  expected;
-  hint;
-  detail;
-  constructor(reason, hint) {
-    let recovery;
-    if (reason === "copy-src") recovery = "enable-copy-src";
-    else if (reason === "resource" || reason === "readback-failed") recovery = "retry-readback";
-    else recovery = "draw-current-frame";
-    super(`current-frame observation unavailable: ${reason}`);
-    this.name = "ObservationUnavailableError";
-    this.expected = "a fresh producer-owned rgba16float current-frame observation";
-    this.hint = hint;
-    this.detail = { reason, recovery };
-  }
-};
-var FrameReceiptStaleError = class extends Error {
-  code = "frame-receipt-stale";
-  expected = "the observation receipt belongs to the active device generation";
-  hint = "draw a new frame and call observe with its returned FrameReceipt";
-  detail;
-  constructor(detail) {
-    super("frame receipt belongs to a retired device generation");
-    this.name = "FrameReceiptStaleError";
-    this.detail = detail;
-  }
-};
-var RendererContractFailureError = class extends Error {
-  code = "renderer-contract-failed";
-  expected = "renderer owner contracts remain valid at the public boundary";
-  hint = "repair the owner contract and retry the operation";
-  detail;
-  constructor(operation, cause) {
-    super(`renderer ${operation} contract failed: ${cause}`);
-    this.name = "RendererContractFailureError";
-    this.detail = { operation, cause };
-  }
-};
-var RENDERER_OPERATION_ERROR_POLICY = {
-  "world-lease-invalid": {
-    expected: "every render World is represented by a live lease owned by this Renderer",
-    hint: "attach the World to this Renderer and use the returned lease"
-  },
-  "frame-input-invalid": {
-    expected: "the frame input references attached leases and a valid immutable RenderProfile",
-    hint: "repair the frame input and retry draw or setProfile"
-  },
-  "scene-projection-failed": {
-    expected: "the attached World projects into the renderer-owned RenderScene",
-    hint: "inspect the structured cause, repair the World publication, and retry draw"
-  },
-  "asset-binding-failed": {
-    expected: "all frame assets resolve to valid renderer-owned bindings",
-    hint: "inspect the structured cause, rebuild or cold-cook the asset, and retry draw"
-  },
-  "feature-plan-failed": {
-    expected: "every installed RenderFeature produces a valid declarative plan",
-    hint: "inspect the feature cause, repair its plan, and retry draw"
-  },
-  "graph-build-failed": {
-    expected: "the Standard graph builds from the active profile and feature plans",
-    hint: "inspect the graph cause, repair the profile or plan, and retry"
-  },
-  "device-operation-failed": {
-    expected: "the active device generation completes the renderer-owned operation",
-    hint: "inspect renderer state and the structured cause, then retry or recover"
-  },
-  "surface-unavailable": {
-    expected: "the presentation surface accepts the requested lifecycle operation",
-    hint: "inspect renderer state, then restore the surface or create a new Renderer"
-  },
-  "renderer-state-invalid": {
-    expected: "the Renderer is in a state that accepts the requested operation",
-    hint: "inspect renderer state and choose retry, restoreSurface, recover, or stop"
-  },
-  "recovery-failed": {
-    expected: "one recovery attempt publishes a complete replacement device generation",
-    hint: "inspect the structured cause and retry recover after the host-selected delay"
-  },
-  "cleanup-failed": {
-    expected: "Renderer disposal completes every registered cleanup in reverse ownership order",
-    hint: "inspect the ordered cleanup causes; the Renderer remains disposed and must not be reused"
-  }
-};
-var RendererOperationError = class extends Error {
-  code;
-  expected;
-  hint;
-  detail;
-  constructor(code, detail) {
-    const policy = RENDERER_OPERATION_ERROR_POLICY[code];
-    super(`${code}: ${policy.expected}`);
-    this.name = "RendererOperationError";
-    this.code = code;
-    this.expected = policy.expected;
-    this.hint = policy.hint;
-    this.detail = detail;
-  }
-};
 function stageFailure(identity) {
   return {
     code: "render-feature-stage-failed",
@@ -4627,6 +4211,11 @@ function buildPbrViewBglEntries(caps) {
       binding: 8,
       visibility: GPU_SHADER_STAGE_FRAGMENT,
       texture: { sampleType: "depth", viewDimension: "2d" }
+    },
+    {
+      binding: 10,
+      visibility: GPU_SHADER_STAGE_VERTEX,
+      buffer: { type: "uniform", hasDynamicOffset: true }
     }
   ];
 }
@@ -4831,7 +4420,7 @@ function buildBindGroupLayoutDescriptor(spec, options) {
       const desc = createHdrpBindGroupLayoutDescriptor(caps.storageBuffer);
       return {
         label: desc.label ?? "hdrp-unified-bgl-group2",
-        entries: desc.entries ?? []
+        entries: [...desc.entries ?? []]
       };
     }
     case "fullscreen-post": {
@@ -7598,12 +7187,47 @@ function clampPcfKernelSize(value) {
 
 // src/record/view-ubo.ts
 var VIEW_UNIFORM_BYTES = 960;
+var POINTS_LINES_VIEW_BYTES = 160;
+var POINTS_LINES_VIEW_SLOT_STRIDE = 256;
+var POINTS_LINES_VIEW_SLOT_COUNT = 1024;
+var POINTS_LINES_VIEW_BUFFER_SIZE = POINTS_LINES_VIEW_SLOT_STRIDE * POINTS_LINES_VIEW_SLOT_COUNT;
 var VIEW_UNIFORM_SLOT_STRIDE = 1024;
 var POINT_SHADOW_VIEW_SLOT_COUNT = 24;
 var VIEW_UNIFORM_BUFFER_SIZE = VIEW_UNIFORM_SLOT_STRIDE * (1 + POINT_SHADOW_VIEW_SLOT_COUNT);
 function pointShadowViewOffset(layer, face) {
   return VIEW_UNIFORM_SLOT_STRIDE * (1 + layer * 6 + face);
 }
+function writePointsLinesViewUbo(queue, buffer, camera, width, height, model, style, byteOffset = 0) {
+  const projection = computeProjectionMatrix(camera);
+  const view = computeViewMatrix(camera);
+  const worldViewProj = mat4.create();
+  mat4.multiply(worldViewProj, projection, view);
+  const payload = new Float32Array(40);
+  payload.set(worldViewProj);
+  if (model === void 0) {
+    payload[16] = 1;
+    payload[21] = 1;
+    payload[26] = 1;
+    payload[31] = 1;
+  } else {
+    for (let index = 0; index < 16; index += 1) {
+      payload[16 + index] = model[index] ?? 0;
+    }
+  }
+  payload[32] = width;
+  payload[33] = height;
+  if (style?.kind === "points") {
+    payload[36] = style.sizePx;
+    payload[38] = style.shape === "circle" ? 1 : 0;
+  } else if (style?.kind === "lines") {
+    payload[36] = style.widthPx;
+    payload[37] = 1;
+  } else {
+    payload[36] = 1;
+  }
+  const uploaded = queue.writeBuffer(buffer, byteOffset, payload);
+  if (!uploaded.ok) throw uploaded.error;
+}
 function writeViewUbo(queue, viewUniformBuffer, camera, light, lights, spotShadowSnapshots) {
   const projMatrix = computeProjectionMatrix(camera);
   const viewMatrix = computeViewMatrix(camera);
@@ -7719,7 +7343,8 @@ function buildPerFrameBindGroups(internals, frameState, pipelineState, hasValida
           shadowSampler,
           b5View,
           pipelineState.shadowParamsBuffer,
-          b8View
+          b8View,
+          pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer
         ],
         "view-main",
         () => {
@@ -7806,11 +7431,22 @@ function buildPerFrameBindGroups(internals, frameState, pipelineState, hasValida
                   kind: "textureView",
                   value: b8View
                 }
+              },
+              {
+                binding: 10,
+                resource: {
+                  kind: "buffer",
+                  value: {
+                    buffer: pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer,
+                    size: POINTS_LINES_VIEW_BYTES
+                  }
+                }
               }
               // feat-20260625-spot-light-shadow-mapping w25: the per-spot
               // fragment-read lightViewProj matrices fold into the View UBO
               // (binding 0, `view.spotLightViewProj`) — no standalone binding 9
-              // (WebGL2 fragment uniform-buffer budget). binding 8 is the last.
+              // (WebGL2 fragment uniform-buffer budget). binding 10 is the
+              // dedicated vertex-only Points/Lines viewport UBO.
             ]
           });
           if (!viewBindGroupResult.ok) throw viewBindGroupResult.error;
@@ -8306,6 +7942,53 @@ function resolveSkyboxActive(internals, frameState, camera, skybox) {
   return { tonemapActive, skyboxActive };
 }
 
+// src/points-lines/record.ts
+var POINTS_LINES_MATERIAL_SHADER_ID = "forgeax::points-lines";
+function createPointsLinesLaneContract(lane, backend) {
+  return {
+    lane,
+    backend,
+    authoring: "shared",
+    evidence: backend === "null" ? "structural-only" : "runtime",
+    material: {
+      source: "MaterialAsset",
+      shaderId: POINTS_LINES_MATERIAL_SHADER_ID,
+      shadingModel: "unlit",
+      clusteredLighting: false,
+      lit: false
+    },
+    graph: { additionalAttachments: 0, additionalPasses: 0 },
+    shadowDrawCount: 0,
+    capabilities: { compute: false, storage: false, indirect: false }
+  };
+}
+function createPointsLinesRecordPlan(snapshot, geometry, contract) {
+  const primitiveCount = geometry.pointCount + geometry.segmentCount;
+  const visible = snapshot.visible && primitiveCount > 0;
+  const conservativeMarginPx = snapshot.style?.kind === "points" ? snapshot.style.sizePx * 0.5 : (snapshot.style?.widthPx ?? 0) * 0.5;
+  return {
+    lane: contract.lane,
+    backend: contract.backend,
+    materialShaderId: POINTS_LINES_MATERIAL_SHADER_ID,
+    component: geometry.component,
+    meshGeneration: snapshot.meshGeneration,
+    materialGeneration: snapshot.materialGeneration,
+    vertexCount: primitiveCount * 4,
+    indexCount: primitiveCount * 6,
+    drawCount: visible ? 1 : 0,
+    shadowDrawCount: 0,
+    conservativeMarginPx,
+    graph: contract.graph
+  };
+}
+function createPointsLinesLaneAdapter(lane, backend) {
+  const contract = createPointsLinesLaneContract(lane, backend);
+  return {
+    contract,
+    createRecordPlan: (snapshot, geometry) => createPointsLinesRecordPlan(snapshot, geometry, contract)
+  };
+}
+
 // src/record/render-context.ts
 var STANDARD_PBR_UBO_SIZE = 304;
 var MATERIAL_PER_ENTITY_STRIDE = 512;
@@ -8894,6 +8577,14 @@ function submitSubmeshDraws(pass, state, pipeline, instanceDraws, indexed, index
     }
   }
 }
+function recordPointsLinesDraw(pass, plan) {
+  if (plan.drawCount === 0) return;
+  if (plan.indexCount > 0) {
+    pass.drawIndexed(plan.indexCount, 1, 0, 0, 0);
+    return;
+  }
+  pass.draw(plan.vertexCount, 1, 0, 0);
+}
 function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sampleCount, meshGroup2, meshBindGroup, resolveMaterialBindGroup, passKind = "forward") {
   const {
     runtime,
@@ -8904,7 +8595,8 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
     tonemapActive,
     msaaActive,
     validatedOrdered,
-    splitLdrSprite
+    splitLdrSprite,
+    viewBindGroup
   } = c;
   const colorFormatOverride = c.transparentColorFormat;
   let lastVertexBuffer = null;
@@ -8989,6 +8681,9 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
   for (let i = 0; i < validatedOrdered.length; i++) {
     const entry = validatedOrdered[i];
     if (entry === void 0) continue;
+    const pointsLinesSubmission = c.pointsLines?.prepare(entry, frameState.isHdrpActive);
+    if (entry.source.pointsLines !== void 0 && pointsLinesSubmission?.plan.drawCount !== 1)
+      continue;
     if (passKind === "forward" && c.gpuDrivenEntityKeys.has(worldEntityKey(entry.source.worldId, entry.source.entityKey))) {
       continue;
     }
@@ -8999,6 +8694,66 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
       pass.setStencilReference(stencilReference);
       lastStencilReference = stencilReference;
     }
+    if (pointsLinesSubmission !== void 0 && entry.source.pointsLines !== void 0) {
+      const pointsLinesMaterial = {
+        ...entry.source.material,
+        materialShaderId: POINTS_LINES_MATERIAL_SHADER_ID,
+        materialParamSchema: runtime.getParamSchema?.(POINTS_LINES_MATERIAL_SHADER_ID) ?? entry.source.material.materialParamSchema
+      };
+      const materialSlot = materialSlotIndices[i]?.[0] ?? 0;
+      const pointsLinesBindGroup = resolveMaterialBindGroup(
+        materialSlot,
+        pointsLinesMaterial,
+        entry.source.entityKey,
+        entry.world ?? c.world
+      );
+      const pointsLinesPipeline = resolveMaterialPipeline(
+        POINTS_LINES_MATERIAL_SHADER_ID,
+        {
+          ...pointsLinesMaterial.renderState,
+          cullMode: "none"
+        },
+        "triangle-list",
+        "uint32",
+        void 0,
+        colorFormatOverride,
+        pointsLinesSubmission.layoutProjection
+      );
+      if (pointsLinesPipeline === null) continue;
+      if (pipelineState.pointsLinesViewBuffer === void 0) continue;
+      writePointsLinesViewUbo(
+        runtime.device.queue,
+        pipelineState.pointsLinesViewBuffer,
+        c.camera,
+        c.targetW,
+        c.targetH,
+        entry.source.transform.world,
+        entry.source.pointsLines.style,
+        i * POINTS_LINES_VIEW_SLOT_STRIDE
+      );
+      pass.setBindGroup(
+        0,
+        viewBindGroup,
+        new Uint32Array([i * POINTS_LINES_VIEW_SLOT_STRIDE]),
+        0,
+        1
+      );
+      pass.setPipeline(pointsLinesPipeline);
+      pass.setVertexBuffer(0, pointsLinesSubmission.vertexBuffer);
+      pass.setIndexBuffer(pointsLinesSubmission.indexBuffer, "uint32");
+      materialGroup1DynamicOffsets[0] = materialSlot * MATERIAL_PER_ENTITY_STRIDE;
+      pass.setBindGroup(1, pointsLinesBindGroup, materialGroup1DynamicOffsets, 0, 1);
+      const pointsLinesMeshGroup = meshBindGroup ?? meshGroup2;
+      if (pointsLinesMeshGroup === null) continue;
+      pass.setBindGroup(2, pointsLinesMeshGroup, meshGroup2DynamicOffsets);
+      pass.setBindGroup(
+        3,
+        identityInstanceDraws[0]?.instanceBindGroup ?? resolveGeometryInstancesBindGroup(c, identityInstanceBuffer)
+      );
+      recordPointsLinesDraw(pass, pointsLinesSubmission.plan);
+      pass.setBindGroup(0, viewBindGroup, [0]);
+      continue;
+    }
     if (entry.mesh.vertexBuffer !== lastVertexBuffer) {
       pass.setVertexBuffer(0, entry.mesh.vertexBuffer.handle);
       lastVertexBuffer = entry.mesh.vertexBuffer;
@@ -9468,7 +9223,7 @@ function recordSpritePass(c, pass, matchedIndices, materialSlotIndices, sampleCo
         { colorLoadOp: "load", depthLoadOp: "load" }
       )
     );
-    spritePass.setBindGroup(0, viewBindGroup);
+    spritePass.setBindGroup(0, viewBindGroup, [0]);
     const spritePremulBlend = {
       depthWriteEnabled: false,
       depthCompare: "less-equal",
@@ -10160,7 +9915,8 @@ function ensureTypedShadowViewBg(c, viewOffset, cascadeOffset, variant) {
         pipelineState.shadowAtlasFallbackTextureView,
         pipelineState.shadowParamsBuffer,
         pipelineState.shadowCasterCascadeBuffer,
-        pipelineState.shadowFallbackTextureView
+        pipelineState.shadowFallbackTextureView,
+        pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer
       ],
       variant,
       () => {
@@ -10213,13 +9969,23 @@ function ensureTypedShadowViewBg(c, viewOffset, cascadeOffset, variant) {
                 value: {
                   buffer: pipelineState.shadowCasterCascadeBuffer,
                   offset: cascadeOffset,
-                  size: 80
+                  size: POINTS_LINES_VIEW_BYTES
                 }
               }
             },
             {
               binding: 8,
               resource: { kind: "textureView", value: pipelineState.shadowFallbackTextureView }
+            },
+            {
+              binding: 10,
+              resource: {
+                kind: "buffer",
+                value: {
+                  buffer: pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer,
+                  size: 80
+                }
+              }
             }
           ]
         });
@@ -10270,7 +10036,7 @@ function encodeDirectionalShadowPass(c, pass, cascadeIndex, viewport) {
   c.frameState.directionalShadowCacheRecorded = true;
   pass.setViewport(viewport.x, viewport.y, viewport.w, viewport.h, 0, 1);
   pass.setPipeline(pipeline);
-  pass.setBindGroup(0, viewBg);
+  pass.setBindGroup(0, viewBg, [0]);
   pass.setBindGroup(1, materialBg, [0]);
   recordShadowCasterDraws(
     c,
@@ -10294,7 +10060,7 @@ function encodePointShadowPass(c, pass, snapshotIndex, face) {
   const materialBg = ensureSpotShadowMaterialBg(c);
   if (pipeline === null || viewBg === null || materialBg === null) return;
   pass.setPipeline(pipeline);
-  pass.setBindGroup(0, viewBg);
+  pass.setBindGroup(0, viewBg, [0]);
   pass.setBindGroup(1, materialBg, [0]);
   recordShadowCasterDraws(
     c,
@@ -10332,7 +10098,7 @@ function encodeSpotShadowPass(c, pass, snapshotIndex) {
     1
   );
   pass.setPipeline(pipeline);
-  pass.setBindGroup(0, viewBg);
+  pass.setBindGroup(0, viewBg, [0]);
   pass.setBindGroup(1, materialBg, [0]);
   recordShadowCasterDraws(
     c,
@@ -10819,8 +10585,8 @@ function recordMainPass(c, selector, options, graphPass) {
         owner.world ?? world
       );
     }
-    const resolveMaterialBindGroup = (materialSlot, material, entityKey, materialWorld = world) => preparedMaterialBindGroups[materialSlot] ?? buildPerSubmeshMaterialBg2(material, entityKey, materialWorld);
-    pass.setBindGroup(0, viewBindGroup);
+    const resolveMaterialBindGroup = (materialSlot, material, entityKey, materialWorld = world) => material.materialShaderId !== POINTS_LINES_MATERIAL_SHADER_ID ? preparedMaterialBindGroups[materialSlot] ?? buildPerSubmeshMaterialBg2(material, entityKey, materialWorld) : buildPerSubmeshMaterialBg2(material, entityKey, materialWorld);
+    pass.setBindGroup(0, viewBindGroup, [0]);
     const recordGeometry = () => {
       recordGeometryDraws(
         c,
@@ -10910,7 +10676,7 @@ function recordSkyboxPass(c, graphPass) {
             binding: 2,
             resource: {
               kind: "buffer",
-              value: { buffer: pipelineState.viewUniformBuffer }
+              value: { buffer: pipelineState.viewUniformBuffer, size: VIEW_UNIFORM_BYTES }
             }
           },
           {
@@ -14829,7 +14595,7 @@ var GpuDrivenProduction = class {
         return ok({
           accesses,
           encode: (viewBindGroup, pass, resources) => {
-            pass.setBindGroup(0, viewBindGroup);
+            pass.setBindGroup(0, viewBindGroup, [0]);
             let currentPipeline;
             let currentVertex;
             let currentIndex;
@@ -14905,6 +14671,305 @@ var GpuDrivenProduction = class {
   }
 };
 
+// src/points-lines/expansion-cache.ts
+var PointsLinesExpansionCache = class {
+  entries = /* @__PURE__ */ new Map();
+  getOrCreate(snapshot, mesh) {
+    if (snapshot.component === void 0 || snapshot.style === void 0) {
+      return emptyGeometry(snapshot);
+    }
+    const key = expansionKey(snapshot);
+    const cached = this.entries.get(key);
+    if (cached !== void 0) return cached;
+    const geometry = deriveExpandedGeometry(snapshot, mesh, key);
+    this.entries.set(key, geometry);
+    return geometry;
+  }
+  clear() {
+    this.entries.clear();
+  }
+  get size() {
+    return this.entries.size;
+  }
+};
+function expansionKey(snapshot) {
+  return `mesh:${snapshot.meshHandle}:${snapshot.meshGeneration}:component=${snapshot.component ?? "none"}`;
+}
+function deriveExpandedGeometry(snapshot, mesh, key) {
+  const component = snapshot.component;
+  const style = snapshot.style;
+  if (component === void 0 || style === void 0) return emptyGeometry(snapshot);
+  const sourcePositions = readPositions(mesh);
+  const positions = [];
+  const vertices = [];
+  const indices = [];
+  let sourceCursor = 0;
+  let pointCount = 0;
+  let segmentCount = 0;
+  const expectedTopology = component === "Points" ? "point-list" : "line-list";
+  for (const submesh of mesh.submeshes) {
+    if (submesh.topology !== expectedTopology) {
+      sourceCursor += submesh.vertexCount;
+      continue;
+    }
+    const elements = mesh.indices !== void 0 && submesh.indexCount > 0 ? Array.from(
+      mesh.indices.slice(submesh.indexOffset, submesh.indexOffset + submesh.indexCount)
+    ) : Array.from({ length: submesh.vertexCount }, (_, index) => sourceCursor + index);
+    for (const index of elements) {
+      const offset2 = index * 3;
+      positions.push(
+        sourcePositions[offset2] ?? 0,
+        sourcePositions[offset2 + 1] ?? 0,
+        sourcePositions[offset2 + 2] ?? 0
+      );
+    }
+    if (component === "Points") {
+      pointCount += elements.length;
+      for (const index of elements) {
+        const offset2 = index * 3;
+        const position = [
+          sourcePositions[offset2] ?? 0,
+          sourcePositions[offset2 + 1] ?? 0,
+          sourcePositions[offset2 + 2] ?? 0
+        ];
+        if (style.kind !== "points") continue;
+        emitQuad(vertices, indices, position, position);
+      }
+    } else {
+      segmentCount += Math.floor(elements.length / 2);
+      for (let element = 0; element + 1 < elements.length; element += 2) {
+        const startOffset = (elements[element] ?? 0) * 3;
+        const endOffset = (elements[element + 1] ?? 0) * 3;
+        emitQuad(
+          vertices,
+          indices,
+          [
+            sourcePositions[startOffset] ?? 0,
+            sourcePositions[startOffset + 1] ?? 0,
+            sourcePositions[startOffset + 2] ?? 0
+          ],
+          [
+            sourcePositions[endOffset] ?? 0,
+            sourcePositions[endOffset + 1] ?? 0,
+            sourcePositions[endOffset + 2] ?? 0
+          ]
+        );
+      }
+    }
+    sourceCursor += submesh.vertexCount;
+  }
+  const expanded = new Float32Array(positions);
+  const expandedVertices = new Float32Array(vertices);
+  const expandedIndices = new Uint32Array(indices);
+  return {
+    key,
+    component,
+    positions: expanded,
+    vertices: expandedVertices,
+    indices: expandedIndices,
+    sourceVertexCount: sourcePositions.length / 3,
+    pointCount,
+    segmentCount,
+    expandedVertexCount: expandedVertices.length / 8,
+    expandedIndexCount: expandedIndices.length,
+    sourceBytes: mesh.vertices.byteLength + (mesh.indices?.byteLength ?? 0),
+    derivedBytes: expandedVertices.byteLength + expandedIndices.byteLength,
+    bounds: boundsOf(expanded)
+  };
+}
+function emitQuad(vertices, indices, start, end) {
+  const base = vertices.length / 8;
+  const corners = [
+    [-1, -1],
+    [-1, 1],
+    [1, -1],
+    [1, 1]
+  ];
+  for (const [x, y] of corners) {
+    vertices.push(
+      start[0] ?? 0,
+      start[1] ?? 0,
+      start[2] ?? 0,
+      end[0] ?? 0,
+      end[1] ?? 0,
+      end[2] ?? 0,
+      x,
+      y
+    );
+  }
+  indices.push(base, base + 1, base + 2, base + 2, base + 1, base + 3);
+}
+function readPositions(mesh) {
+  const attribute = mesh.attributes.position;
+  if (attribute instanceof Float32Array && attribute.length >= 3) {
+    return attribute;
+  }
+  const vertexCount = mesh.vertices.length / 3;
+  const stride = vertexCount > 0 ? mesh.vertices.length / vertexCount : 3;
+  const positions = new Float32Array(vertexCount * 3);
+  for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+    const source = vertex * stride;
+    positions.set(mesh.vertices.subarray(source, source + 3), vertex * 3);
+  }
+  return positions;
+}
+function boundsOf(positions) {
+  if (positions.length === 0) return new Float32Array(0);
+  const bounds = new Float32Array([Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity]);
+  for (let index = 0; index < positions.length; index += 3) {
+    bounds[0] = Math.min(bounds[0] ?? Infinity, positions[index] ?? 0);
+    bounds[1] = Math.min(bounds[1] ?? Infinity, positions[index + 1] ?? 0);
+    bounds[2] = Math.min(bounds[2] ?? Infinity, positions[index + 2] ?? 0);
+    bounds[3] = Math.max(bounds[3] ?? -Infinity, positions[index] ?? 0);
+    bounds[4] = Math.max(bounds[4] ?? -Infinity, positions[index + 1] ?? 0);
+    bounds[5] = Math.max(bounds[5] ?? -Infinity, positions[index + 2] ?? 0);
+  }
+  return bounds;
+}
+function emptyGeometry(snapshot) {
+  return {
+    key: `empty:${snapshot.entityKey}`,
+    component: snapshot.component ?? "Points",
+    positions: new Float32Array(0),
+    vertices: new Float32Array(0),
+    indices: new Uint32Array(0),
+    sourceVertexCount: 0,
+    pointCount: 0,
+    segmentCount: 0,
+    expandedVertexCount: 0,
+    expandedIndexCount: 0,
+    sourceBytes: 0,
+    derivedBytes: 0,
+    bounds: new Float32Array(0)
+  };
+}
+
+// src/points-lines/inspection.ts
+function inspectPointsLines(input) {
+  const { snapshot } = input;
+  if (snapshot.component === void 0) {
+    throw new Error("Points/Lines inspection requires a retained style component");
+  }
+  return {
+    entityKey: snapshot.entityKey,
+    worldId: snapshot.worldId,
+    component: snapshot.component,
+    meshHandle: snapshot.meshHandle,
+    meshGeneration: snapshot.meshGeneration,
+    materialHandle: snapshot.materialHandle,
+    materialGeneration: snapshot.materialGeneration,
+    style: snapshot.style ?? { kind: "lines", widthPx: 0 },
+    topology: input.topology,
+    lane: input.lane,
+    pointCount: input.pointCount,
+    segmentCount: input.segmentCount,
+    sourceBytes: input.sourceBytes,
+    derivedBytes: input.derivedBytes,
+    cache: { ...input.cache },
+    drawCount: input.drawCount,
+    uploadBytes: input.uploadBytes,
+    lastKnownGood: input.lastKnownGood,
+    ...input.refusal === void 0 ? {} : { refusal: { ...input.refusal } }
+  };
+}
+var PointsLinesPreparation = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  live;
+  pendingCandidateBytes = 0;
+  status = "empty";
+  uploads = 0;
+  rebuilds = 0;
+  failures = 0;
+  prepare(snapshot, mesh) {
+    const geometry = this.options.cache.getOrCreate(snapshot, mesh);
+    if (this.live?.geometry.key === geometry.key) {
+      this.live = {
+        ...this.live,
+        snapshot,
+        uploadedBytes: 0
+      };
+      this.status = "resident";
+      return ok$1(this.live);
+    }
+    this.pendingCandidateBytes = geometry.derivedBytes;
+    const created = this.options.adapter.create(geometry);
+    if (!created.ok) return this.fail(snapshot, created.error);
+    const candidate = created.value;
+    const uploaded = this.options.adapter.upload(candidate, geometry);
+    if (!uploaded.ok) {
+      this.options.adapter.destroy(candidate);
+      return this.fail(snapshot, uploaded.error);
+    }
+    this.uploads += 1;
+    const validated = this.options.adapter.validate(candidate, geometry);
+    if (!validated.ok) {
+      this.options.adapter.destroy(candidate);
+      return this.fail(snapshot, validated.error);
+    }
+    const previous = this.live;
+    this.live = {
+      resource: candidate,
+      geometry,
+      snapshot,
+      uploadedBytes: uploaded.value,
+      lastKnownGood: true
+    };
+    this.pendingCandidateBytes = 0;
+    this.status = "resident";
+    this.rebuilds += 1;
+    if (previous !== void 0) this.options.adapter.destroy(previous.resource);
+    return ok$1(this.live);
+  }
+  resetForDeviceLoss() {
+    if (this.live !== void 0) this.options.adapter.destroy(this.live.resource);
+    this.live = void 0;
+    this.pendingCandidateBytes = 0;
+    this.status = "rebuild-pending";
+  }
+  lastKnownGood() {
+    return this.live;
+  }
+  inspect() {
+    return {
+      status: this.status,
+      lastKnownGood: this.live?.lastKnownGood ?? false,
+      liveResource: this.live?.resource,
+      liveBytes: this.live?.geometry.derivedBytes ?? 0,
+      candidateBytes: this.pendingCandidateBytes,
+      cacheEntries: this.options.cache.size,
+      uploads: this.uploads,
+      rebuilds: this.rebuilds,
+      failures: this.failures
+    };
+  }
+  fail(snapshot, cause) {
+    this.pendingCandidateBytes = 0;
+    this.failures += 1;
+    return err$1(
+      new PointsLinesPrepareFailedError({
+        owner: "points-lines",
+        generation: snapshot.meshGeneration,
+        stage: "prepare",
+        cause: cause.message,
+        lastKnownGood: this.live !== void 0
+      })
+    );
+  }
+};
+function createPointsLinesLanePreparationAdapter(lane, backend, options) {
+  const preparation = new PointsLinesPreparation(options);
+  return {
+    contract: createPointsLinesLaneContract(lane, backend),
+    prepare: (snapshot, mesh) => preparation.prepare(snapshot, mesh),
+    resetForDeviceLoss: () => preparation.resetForDeviceLoss(),
+    lastKnownGood: () => preparation.lastKnownGood(),
+    inspect: () => preparation.inspect()
+  };
+}
+
 // src/instance-buffer-cache.ts
 function destroyInstanceBufferEntries(entries, errorRegistry) {
   for (const entry of entries) {
@@ -15515,10 +15580,12 @@ var RenderFeatureRasterGraphProjection = class {
       for (const [group, reference] of draw.bindings.entries()) {
         const binding = resolved(snapshot, reference);
         if (binding?.kind !== "bindings") throw missing(featureIdentity, order);
-        const handle = binding.handle ?? this.resolveBindings?.({ frame, binding, resources, resolveTarget: this.resolveTarget });
+        const resolvedBindings = binding.handle ?? this.resolveBindings?.({ frame, binding, resources, resolveTarget: this.resolveTarget });
+        const handle = resolvedBindings !== void 0 && typeof resolvedBindings === "object" && "handle" in resolvedBindings ? resolvedBindings.handle : resolvedBindings;
         if (handle === void 0) throw missing(featureIdentity, order);
         const targetGroup = binding.descriptor?.values.group ?? group;
-        pass.setBindGroup(targetGroup, handle, binding.dynamicOffsets);
+        const dynamicOffsets = resolvedBindings !== void 0 && typeof resolvedBindings === "object" && "handle" in resolvedBindings ? resolvedBindings.dynamicOffsets : binding.dynamicOffsets;
+        pass.setBindGroup(targetGroup, handle, dynamicOffsets);
       }
       for (const vertex of draw.vertexData) {
         const handle = buffers.vertex.get(vertex.resource);
@@ -15786,7 +15853,7 @@ function resolveTargetBindings(input) {
     return created2.value;
   }
   if (sceneDepth === void 0) {
-    return buildPerFrameBindGroups(
+    const viewBindGroup = buildPerFrameBindGroups(
       frame.runtime,
       frame.frameState,
       frame.pipelineState,
@@ -15796,7 +15863,8 @@ function resolveTargetBindings(input) {
         directionalShadow: frame.frameState.currentDirectionalShadowView ?? void 0,
         spotShadow: frame.frameState.currentSpotShadowView ?? void 0
       }
-    ).viewBindGroup ?? void 0;
+    ).viewBindGroup;
+    return viewBindGroup === null ? void 0 : { handle: viewBindGroup, dynamicOffsets: [0] };
   }
   const target3 = input.resolveTarget(sceneDepth);
   if (target3 === void 0) return void 0;
@@ -16023,7 +16091,7 @@ var EMPTY_ENTITY_KEYS = /* @__PURE__ */ new Set();
 function runRecordProfilePhase(runner, phase, action) {
   return runner === void 0 ? action() : runner(phase, action);
 }
-function recordFrame(internals, world, cameras, lights, renderables, transparentDispatch, frameState, dispatchCounts, bindGroupCounts, skylight, skylightCount, skybox, skyboxCount, postProcessParams, worlds = [world], profilePhase, gpuDriven, renderReadLeases, featureGraphCandidate) {
+function recordFrame(internals, world, cameras, lights, renderables, transparentDispatch, frameState, dispatchCounts, bindGroupCounts, skylight, skylightCount, skybox, skyboxCount, postProcessParams, worlds = [world], profilePhase, gpuDriven, renderReadLeases, featureGraphCandidate, pointsLinesOwner) {
   let activeCameras = cameras;
   if (activeCameras.length === 0) {
     internals.errorRegistry.fire(
@@ -16220,6 +16288,15 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
           lights,
           frameState.spotShadowSnapshots
         );
+        if (pipelineState.pointsLinesViewBuffer !== void 0) {
+          writePointsLinesViewUbo(
+            internals.device.queue,
+            pipelineState.pointsLinesViewBuffer,
+            camera,
+            targetW,
+            targetH
+          );
+        }
         writeShadowCasterUniforms(
           internals.device.queue,
           pipelineState.shadowCasterCascadeBuffer,
@@ -16310,6 +16387,7 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       materialSlots,
       materialSlotOwners,
       materialSlotCount,
+      pointsLines: pointsLinesOwner,
       materialBgAssemblyCache: frameState.materialBgAssemblyCache,
       directionalShadowCacheReuse: directionalShadowCache.reuse,
       ...profilePhase !== void 0 ? { profilePhase } : {}
@@ -16788,15 +16866,19 @@ function resolveMeshMaterialBindings(mesh, rendererOverrides, deps) {
   return { ok: true, bindings, diagnostics };
 }
 
-// src/systems/active-camera.ts
-var ACTIVE_CAMERA_KEY = "ActiveCamera";
-function getActiveCamera(world) {
-  if (!world.hasResource(ACTIVE_CAMERA_KEY)) return void 0;
-  return world.getResource(ACTIVE_CAMERA_KEY);
-}
-function selectActiveCameraIndex(cameraEntities, activeEntity) {
-  if (activeEntity === void 0) return -1;
-  return cameraEntities.indexOf(activeEntity);
+// src/points-lines/bounds.ts
+function expandPointsLinesBounds(bounds, style) {
+  if (bounds.length < 6 || style === void 0) return new Float32Array(bounds);
+  const marginPx = style.kind === "points" ? style.sizePx * 0.5 : style.widthPx * 0.5;
+  if (!Number.isFinite(marginPx) || marginPx <= 0) return new Float32Array(bounds);
+  return new Float32Array([
+    (bounds[0] ?? 0) - marginPx,
+    (bounds[1] ?? 0) - marginPx,
+    (bounds[2] ?? 0) - marginPx,
+    (bounds[3] ?? 0) + marginPx,
+    (bounds[4] ?? 0) + marginPx,
+    (bounds[5] ?? 0) + marginPx
+  ]);
 }
 
 // src/render-system-extract.ts
@@ -16832,7 +16914,9 @@ function appendMaterialDispatchEntries(pendingDispatch, passes, entity, material
       layer,
       tags: passState.tags ?? {},
       renderState: pipelineRenderState(passState),
-      defines: pass.program.moduleSlots,
+      // Material module identity is already closed in the cooked program.
+      // It must never become a draw-time define map.
+      defines: void 0,
       vertexEntry: pass.program.vertexEntry,
       fragmentEntry: pass.program.fragmentEntry,
       materialShaderId: runtimeMaterialShaderId(pass.program.module, pass.name),
@@ -17023,7 +17107,7 @@ function isEngineInjectedTextureField(shaderId, fieldName) {
 function materialParametersToParamSchema(parameters, shaderId) {
   const engineInjectedTextureFields = isStandardPbrMaterialShader(shaderId) ? ENGINE_INJECTED_TEXTURE_FIELDS : void 0;
   return parameters.flatMap((parameter) => {
-    if (parameter.static || parameter.type === "bool") return [];
+    if (parameter.type === "bool") return [];
     if (parameter.type === "texture") {
       if (engineInjectedTextureFields?.has(parameter.name) === true) return [];
       return [{ name: parameter.name, type: "texture2d" }];
@@ -17536,9 +17620,9 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
       });
       const frame = extractFrame(world, prepared);
       framesByWorld.set(wi, frame);
-    } catch (err28) {
+    } catch (err29) {
       try {
-        createWorldInternalView(world)._routeError(err28, {
+        createWorldInternalView(world)._routeError(err29, {
           severity: Severity.Error,
           systemName: `RenderSystem.extractFrames(world[${wi}])`
         });
@@ -17571,7 +17655,11 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
     }
     hiddenEntityReports.push(...f.hiddenEntityReports);
     for (const r of f.renderables) {
-      renderables.push({ ...r, worldId: wId });
+      renderables.push({
+        ...r,
+        worldId: wId,
+        ...r.pointsLines === void 0 ? {} : { pointsLines: { ...r.pointsLines, worldId: wId } }
+      });
     }
     for (const d of f.dispatch) {
       dispatchEntries.push({ ...d, renderableIndex: (d.renderableIndex ?? 0) + base });
@@ -18133,7 +18221,10 @@ function extractFrame(world, context) {
       Layer,
       MorphWeights,
       SpriteRegionOverride,
-      SpriteInstances
+      SpriteInstances,
+      Points,
+      Lines,
+      SortKey
     ]
   }).unwrap();
   const resolveArchVersion = (entity) => {
@@ -18164,6 +18255,10 @@ function extractFrame(world, context) {
     const hasMeshFilter = meshFilter !== void 0;
     const hasSkin = skin !== void 0;
     const hasSpriteInstances = row.has(SpriteInstances);
+    const points = row.get(Points);
+    const lines = row.get(Lines);
+    const sortKey = row.get(SortKey)?.value;
+    const pointsLinesComponent = points !== void 0 ? "Points" : lines !== void 0 ? "Lines" : void 0;
     const isRenderable = hasTransform && hasMeshFilter;
     const fAssetHandle = meshFilter?.assetHandle;
     const fLayerValue = row.get(Layer)?.value;
@@ -18361,28 +18456,28 @@ function extractFrame(world, context) {
           } else {
             const resolvedResult = walkMaterialPassesOverSharedRefs(world, tagged, assets);
             if (!resolvedResult.ok) {
-              const err28 = resolvedResult.error;
-              switch (err28.code) {
+              const err29 = resolvedResult.error;
+              switch (err29.code) {
                 case "material-parent-not-found":
                 case "material-no-effective-pass":
                 case "material-value-unknown":
                 case "material-value-type-mismatch":
                 case "material-contract-program-mismatch":
-                  worldInternal._routeError(err28, {
+                  worldInternal._routeError(err29, {
                     severity: Severity.Error,
-                    systemName: `RenderSystem.extract (${err28.code})`
+                    systemName: `RenderSystem.extract (${err29.code})`
                   });
                   break;
                 case "material-circular-inheritance":
-                  worldInternal._routeError(err28, {
+                  worldInternal._routeError(err29, {
                     severity: Severity.Error,
                     systemName: "RenderSystem.extract (material-circular-inheritance)"
                   });
                   break;
                 default:
-                  worldInternal._routeError(err28, {
+                  worldInternal._routeError(err29, {
                     severity: Severity.Error,
-                    systemName: `RenderSystem.extract (_materialWalk: ${err28.code})`
+                    systemName: `RenderSystem.extract (_materialWalk: ${err29.code})`
                   });
               }
               continue;
@@ -18841,6 +18936,27 @@ function extractFrame(world, context) {
             }
           }
         }
+        const pointsLinesStyle = points !== void 0 ? (() => {
+          const shape = pointShapeFromU32(points.shape);
+          return shape === void 0 ? void 0 : { kind: "points", sizePx: points.sizePx, shape };
+        })() : lines === void 0 ? void 0 : { kind: "lines", widthPx: lines.widthPx };
+        const cullingLocalAabb = expandPointsLinesBounds(localAabb ?? [], pointsLinesStyle);
+        const pointsLines = pointsLinesComponent === void 0 ? void 0 : {
+          worldId: 0,
+          entityKey: entity,
+          component: pointsLinesComponent,
+          meshHandle: assetHandleRaw,
+          meshGeneration: assets?.catalogEpoch ?? 0,
+          materialHandle: handleRaw,
+          materialGeneration: assets?.catalogEpoch ?? 0,
+          style: pointsLinesStyle,
+          layer: layerVal,
+          sortKey,
+          visible: true,
+          sourceBounds: cullingLocalAabb,
+          viewport: { width: 0, height: 0, dpr: 1 },
+          projection: identityProjection()
+        };
         let nonIndexedFirst = 0;
         const gpuDrivenDraws = gpuDrivenSubmeshes.flatMap((submesh) => {
           const drawMaterial = materialsArr[submesh.materialSlot] ?? materialSnap;
@@ -18863,7 +18979,7 @@ function extractFrame(world, context) {
         const baseRenderable = {
           assetHandle: Math.round(fAssetHandle ?? 0),
           transform: transformSnap,
-          ...localAabb !== void 0 ? { localAabb } : {},
+          ...localAabb !== void 0 ? { localAabb: cullingLocalAabb } : {},
           material: materialSnap,
           materials: materialsArr,
           materialBindingSources,
@@ -18873,11 +18989,12 @@ function extractFrame(world, context) {
           entityKey: entity,
           ...skinSlice !== void 0 ? { skin: skinSlice } : {},
           ...morph !== void 0 ? { morph } : {},
-          ...spriteInstancesSnap !== void 0 ? { spriteInstances: spriteInstancesSnap } : {}
+          ...spriteInstancesSnap !== void 0 ? { spriteInstances: spriteInstancesSnap } : {},
+          ...pointsLines !== void 0 ? { pointsLines } : {}
         };
         if (localAabb !== void 0) {
           const worldAabb = box3.create();
-          box3.transformBox3(worldAabb, localAabb, transformSnap.world);
+          box3.transformBox3(worldAabb, cullingLocalAabb, transformSnap.world);
           frustumTotal += 1;
           let visible = frustumPlanes.length === 0;
           for (let ci = 0; ci < frustumPlanes.length; ci++) {
@@ -18968,6 +19085,14 @@ function defaultMaterialSnapshot(materialHandle = 0) {
     materialHandle
   };
 }
+function identityProjection() {
+  const projection = new Float32Array(16);
+  projection[0] = 1;
+  projection[5] = 1;
+  projection[10] = 1;
+  projection[15] = 1;
+  return projection;
+}
 
 // src/gpu-driven/batch-topology.ts
 function eligibleKeys(slot) {
@@ -19762,7 +19887,17 @@ function ownSnapshot(snapshot) {
         transforms: new Float32Array(snapshot.spriteInstances.transforms),
         regions: new Float32Array(snapshot.spriteInstances.regions)
       }
-    }
+    },
+    ...snapshot.pointsLines === void 0 ? {} : { pointsLines: ownPointsLinesSnapshot(snapshot.pointsLines) }
+  };
+}
+function ownPointsLinesSnapshot(snapshot) {
+  return {
+    ...snapshot,
+    style: snapshot.style === void 0 ? void 0 : { ...snapshot.style },
+    sourceBounds: new Float32Array(snapshot.sourceBounds),
+    viewport: { ...snapshot.viewport },
+    projection: new Float32Array(snapshot.projection)
   };
 }
 function withWorld(snapshot, world) {
@@ -19803,6 +19938,10 @@ var RenderScene = class {
   freeSlots = [];
   slotsByWorld = /* @__PURE__ */ new Map();
   slotsByMaterial = /* @__PURE__ */ new Map();
+  // World bounds are a pure projection of each immutable snapshot. Cache the
+  // derived value by snapshot identity so repeated view queries do not redo
+  // the eight-corner transform for every view in the same frame.
+  worldBoundsCache = /* @__PURE__ */ new WeakMap();
   orderedSlots = [];
   materialized;
   slotSnapshot;
@@ -19994,6 +20133,17 @@ var RenderScene = class {
   snapshot(worldId, entityKey) {
     return this.lookup(worldId, entityKey)?.snapshot;
   }
+  pointsLinesSnapshots() {
+    const snapshots = [];
+    for (const slot of this.orderedSlots) {
+      const record = this.slots[slot];
+      const snapshot = record?.snapshot.pointsLines;
+      if (record !== void 0 && snapshot !== void 0) {
+        snapshots.push(ownPointsLinesSnapshot({ ...snapshot, worldId: record.worldId }));
+      }
+    }
+    return Object.freeze(snapshots);
+  }
   slotsForMaterial(materialHandle) {
     const slots = this.slotsByMaterial.get(materialHandle);
     if (slots === void 0) return [];
@@ -20009,8 +20159,14 @@ var RenderScene = class {
     for (const slot of this.orderedSlots) {
       const record = this.slots[slot];
       if (record === void 0) continue;
-      const candidate = worldBounds(record.snapshot);
-      if (candidate !== void 0 && intersects(candidate, bounds)) records.push(record);
+      const snapshot = record.snapshot;
+      let candidate = this.worldBoundsCache.get(snapshot);
+      if (candidate === void 0 && !this.worldBoundsCache.has(snapshot)) {
+        candidate = worldBounds(snapshot) ?? null;
+        this.worldBoundsCache.set(snapshot, candidate);
+      }
+      if (candidate === null || candidate === void 0) continue;
+      if (intersects(candidate, bounds)) records.push(record);
     }
     return records;
   }
@@ -20230,6 +20386,7 @@ var PersistentRenderScene = class {
   gpuOwner;
   gpuDevice;
   gpuStatus = "inactive";
+  pointsLinesInspections = [];
   /** RenderScene owns the per-World material fact cache used during extraction. */
   materialSnapshotCacheStore() {
     return this.materialSnapshotCaches;
@@ -20375,6 +20532,13 @@ var PersistentRenderScene = class {
     this.gpuDevice = void 0;
     this.gpuStatus = this.options.getDevice === void 0 ? "inactive" : "rebuild-pending";
   }
+  setPointsLinesInspections(inspections) {
+    this.pointsLinesInspections = inspections.map((inspection) => ({
+      ...inspection,
+      cache: { ...inspection.cache },
+      ...inspection.refusal === void 0 ? {} : { refusal: { ...inspection.refusal } }
+    }));
+  }
   dispose() {
     this.gpuScene?.dispose();
     this.gpuScene = void 0;
@@ -20382,9 +20546,11 @@ var PersistentRenderScene = class {
     this.gpuDevice = void 0;
     this.gpuStatus = "inactive";
     this.composition = void 0;
+    this.pointsLinesInspections = [];
   }
   inspect() {
     const entry = this.composition;
+    const pointsLines = this.pointsLinesInspections;
     return {
       worldEntitiesScanned: this.worldEntitiesScanned,
       fullRebuilds: this.fullRebuilds,
@@ -20401,7 +20567,8 @@ var PersistentRenderScene = class {
         patches: 0,
         ineligible: 0
       },
-      gpu: this.inspectGpu()
+      gpu: this.inspectGpu(),
+      pointsLines
     };
   }
   compositionGpuDrivenState() {
@@ -20415,6 +20582,9 @@ var PersistentRenderScene = class {
       slots: entry.projection.slotsSnapshot()
     };
   }
+  pointsLinesSnapshots() {
+    return this.composition?.projection.pointsLinesSnapshots() ?? [];
+  }
   inspectGpu() {
     if (this.gpuStatus === "resident" && this.gpuScene !== void 0) {
       return { status: "resident", ...this.gpuScene.inspect() };
@@ -20628,6 +20798,242 @@ function makePreparedPipelinePendingError() {
     hint: "retry the prepared graphics pass on the next frame"
   });
 }
+var StandardPointsLinesOwner = class {
+  constructor(internals) {
+    this.internals = internals;
+  }
+  internals;
+  cache = new PointsLinesExpansionCache();
+  preparations = /* @__PURE__ */ new Map();
+  active = /* @__PURE__ */ new Map();
+  layoutProjection = deriveVertexLayoutProjection({
+    position: new Float32Array(0),
+    normal: new Float32Array(0),
+    uv: new Float32Array(0),
+    tangent: new Float32Array(0)
+  });
+  beginFrame() {
+    this.active.clear();
+  }
+  prepare(entry, clustered) {
+    const snapshot = entry.source.pointsLines;
+    if (snapshot === void 0 || snapshot.component === void 0 || entry.world === void 0) {
+      return void 0;
+    }
+    const key = `${snapshot.worldId}:${snapshot.entityKey}`;
+    const topology = snapshot.component === "Points" ? "point-list" : "line-list";
+    const backend = this.backend();
+    const lane = backend === "wgpu-webgl2" ? "cpu-webgl2" : clustered ? "clustered" : "direct";
+    const meshResult = resolveAssetHandle(
+      entry.world,
+      toShared(entry.source.assetHandle)
+    );
+    const materialResult = resolveAssetHandle(
+      entry.world,
+      toShared(snapshot.materialHandle)
+    );
+    if (!meshResult.ok || !materialResult.ok) {
+      this.publishRefusal(
+        snapshot,
+        new PointsLinesMaterialUnsupportedError({
+          entity: snapshot.entityKey,
+          material: "unresolved",
+          pass: "forward",
+          module: "asset-resolution",
+          reason: "source MeshAsset or MaterialAsset could not be resolved"
+        })
+      );
+      return void 0;
+    }
+    const admission = admitPointsLines({
+      entity: snapshot.entityKey,
+      mesh: meshResult.value,
+      material: materialResult.value,
+      ...snapshot.style?.kind === "points" ? {
+        points: {
+          sizePx: snapshot.style.sizePx,
+          shape: snapshot.style.shape === "circle" ? 1 : 0
+        }
+      } : { lines: { widthPx: snapshot.style?.widthPx ?? 1 } }
+    });
+    if (!admission.ok) {
+      this.publishRefusal(snapshot, admission.error);
+      return void 0;
+    }
+    const geometryKey = this.cache.getOrCreate(snapshot, meshResult.value).key;
+    const prepKey = `${geometryKey}:${lane}:${backend}`;
+    let preparation = this.preparations.get(prepKey);
+    if (preparation === void 0) {
+      preparation = createPointsLinesLanePreparationAdapter(lane, backend, {
+        cache: this.cache,
+        adapter: {
+          create: (geometry) => {
+            const vertex = this.internals.device.createBuffer({
+              label: `points-lines-vertices:${geometryKey}`,
+              size: Math.max(4, geometry.vertices.byteLength),
+              usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
+              mappedAtCreation: false
+            });
+            if (!vertex.ok) return err(vertex.error);
+            const index = this.internals.device.createBuffer({
+              label: `points-lines-indices:${geometryKey}`,
+              size: Math.max(4, geometry.indices.byteLength),
+              usage: GPU_BUFFER_USAGE_INDEX | GPU_BUFFER_USAGE_COPY_DST,
+              mappedAtCreation: false
+            });
+            if (!index.ok) {
+              this.internals.device.destroyBuffer(vertex.value);
+              return err(index.error);
+            }
+            return ok({ vertexBuffer: vertex.value, indexBuffer: index.value });
+          },
+          upload: (resource, geometry) => {
+            if (geometry.vertices.byteLength > 0) {
+              const vertexWrite = this.internals.device.queue.writeBuffer(
+                resource.vertexBuffer,
+                0,
+                geometry.vertices
+              );
+              if (!vertexWrite.ok) return err(vertexWrite.error);
+            }
+            if (geometry.indices.byteLength > 0) {
+              const indexWrite = this.internals.device.queue.writeBuffer(
+                resource.indexBuffer,
+                0,
+                geometry.indices
+              );
+              if (!indexWrite.ok) return err(indexWrite.error);
+            }
+            return ok(geometry.derivedBytes);
+          },
+          validate: (_resource, geometry) => geometry.expandedVertexCount > 0 && geometry.expandedIndexCount > 0 ? ok(void 0) : err(new Error("Points/Lines expansion contains no drawable triangles")),
+          destroy: (resource) => {
+            this.internals.device.destroyBuffer(resource.vertexBuffer);
+            this.internals.device.destroyBuffer(resource.indexBuffer);
+          }
+        }
+      });
+      this.preparations.set(prepKey, preparation);
+    }
+    const prepared = preparation.prepare(snapshot, meshResult.value);
+    if (!prepared.ok) {
+      const lkg = preparation.lastKnownGood();
+      if (lkg !== void 0) {
+        const lkgPlan = createPointsLinesLaneAdapter(lane, backend).createRecordPlan(
+          lkg.snapshot,
+          lkg.geometry
+        );
+        const state2 = preparation.inspect();
+        this.active.set(
+          key,
+          inspectPointsLines({
+            snapshot,
+            topology,
+            lane,
+            pointCount: lkg.geometry.pointCount,
+            segmentCount: lkg.geometry.segmentCount,
+            sourceBytes: lkg.geometry.sourceBytes,
+            derivedBytes: lkg.geometry.derivedBytes,
+            cache: { hit: true, rebuilds: state2.rebuilds, evictions: 0 },
+            drawCount: lkgPlan.drawCount,
+            uploadBytes: 0,
+            lastKnownGood: true,
+            refusal: {
+              code: prepared.error.code,
+              expected: prepared.error.expected,
+              hint: prepared.error.hint,
+              detail: prepared.error.detail,
+              generation: prepared.error.detail.generation,
+              lastKnownGood: true
+            }
+          })
+        );
+        return {
+          plan: lkgPlan,
+          vertexBuffer: lkg.resource.vertexBuffer,
+          indexBuffer: lkg.resource.indexBuffer,
+          layoutProjection: this.layoutProjection
+        };
+      }
+      this.publishRefusal(snapshot, prepared.error);
+      return void 0;
+    }
+    const plan = createPointsLinesLaneAdapter(lane, backend).createRecordPlan(
+      snapshot,
+      prepared.value.geometry
+    );
+    const state = preparation.inspect();
+    this.active.set(
+      key,
+      inspectPointsLines({
+        snapshot,
+        topology,
+        lane,
+        pointCount: prepared.value.geometry.pointCount,
+        segmentCount: prepared.value.geometry.segmentCount,
+        sourceBytes: prepared.value.geometry.sourceBytes,
+        derivedBytes: prepared.value.geometry.derivedBytes,
+        cache: {
+          hit: prepared.value.uploadedBytes === 0,
+          rebuilds: state.rebuilds,
+          evictions: 0
+        },
+        drawCount: plan.drawCount,
+        uploadBytes: prepared.value.uploadedBytes,
+        lastKnownGood: prepared.value.lastKnownGood
+      })
+    );
+    return {
+      plan,
+      vertexBuffer: prepared.value.resource.vertexBuffer,
+      indexBuffer: prepared.value.resource.indexBuffer,
+      layoutProjection: this.layoutProjection
+    };
+  }
+  resetForDeviceLoss() {
+    for (const preparation of this.preparations.values()) preparation.resetForDeviceLoss();
+    this.active.clear();
+  }
+  inspections() {
+    return [...this.active.values()];
+  }
+  backend() {
+    switch (this.internals.device.caps.backendKind) {
+      case "wgpu-webgl2":
+        return "wgpu-webgl2";
+      case "null":
+        return "null";
+      default:
+        return "webgpu";
+    }
+  }
+  publishRefusal(snapshot, error) {
+    this.active.set(
+      `${snapshot.worldId}:${snapshot.entityKey}`,
+      inspectPointsLines({
+        snapshot,
+        topology: snapshot.component === "Points" ? "point-list" : "line-list",
+        lane: "refused",
+        pointCount: 0,
+        segmentCount: 0,
+        sourceBytes: 0,
+        derivedBytes: 0,
+        cache: { hit: false, rebuilds: 0, evictions: 0 },
+        drawCount: 0,
+        uploadBytes: 0,
+        lastKnownGood: false,
+        refusal: {
+          code: error.code,
+          expected: error.expected,
+          hint: error.hint,
+          detail: error.detail,
+          generation: snapshot.meshGeneration,
+          lastKnownGood: false
+        }
+      })
+    );
+  }
+};
 function createRenderSystem(internals) {
   const phaseCatalogRegistration = internals.profiler?.registerPhaseCatalog(
     "render",
@@ -20635,6 +21041,7 @@ function createRenderSystem(internals) {
   );
   let releaseProfilerCatalog = phaseCatalogRegistration?.ok === true ? phaseCatalogRegistration.value : void 0;
   let preparedWorlds = [];
+  const pointsLinesOwner = new StandardPointsLinesOwner(internals);
   const persistentRenderScene = new PersistentRenderScene({
     getDevice: () => internals.device,
     onGpuError: (error) => internals.errorRegistry.fire(error),
@@ -21152,6 +21559,9 @@ function createRenderSystem(internals) {
         gpuDriven: gpuDrivenProduction.inspect()
       };
     },
+    get pointsLinesSnapshots() {
+      return persistentRenderScene.pointsLinesSnapshots();
+    },
     detachScene(world) {
       persistentRenderScene.detach(world);
     },
@@ -21168,6 +21578,7 @@ function createRenderSystem(internals) {
         }
       }
       try {
+        pointsLinesOwner.beginFrame();
         const { cameraOwner, resourceOwner } = opts;
         if (frameState.installedPipelineHandle !== lastBuiltPipelineHandle) {
           resetRenderFeatureGraphState(internals);
@@ -21330,9 +21741,11 @@ function createRenderSystem(internals) {
               }
             },
             renderReadLeases,
-            featureGraphCandidate
+            featureGraphCandidate,
+            pointsLinesOwner
           )
         );
+        persistentRenderScene.setPointsLinesInspections(pointsLinesOwner.inspections());
         if (internals.featureHost !== void 0 && preparedResourceBatches.length > 0) {
           const batches = preparedResourceBatches;
           if (submitted) {
@@ -21348,8 +21761,8 @@ function createRenderSystem(internals) {
             if (!retired.ok) internals.errorRegistry.fire(retired.error);
           }
         }
-      } catch (err28) {
-        const innerError = err28 instanceof RhiError ? err28 : { code: "unknown", message: String(err28), name: err28?.name };
+      } catch (err29) {
+        const innerError = err29 instanceof RhiError ? err29 : { code: "unknown", message: String(err29), name: err29?.name };
         internals.errorRegistry.fire(
           new RhiError({
             code: "webgpu-runtime-error",
@@ -22468,7 +22881,7 @@ function selectHdrpPbrPrewarmVariants(manifestEntry, storageBufferCapable) {
   ) ?? [];
 }
 function selectNoColorPbrVariant(manifestEntry, storageBufferCapable, variantSet) {
-  const hdrpRequested = variantSet === "" || variantSet?.includes("CLUSTER_FORWARD_AVAILABLE=true") === true;
+  const hdrpRequested = variantSet === "" || (variantSet?.includes("CLUSTER_FORWARD_AVAILABLE=true") ?? false);
   return manifestEntry?.variants.find(
     (variant) => variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && variant.defines.VERTEX_COLOR_AVAILABLE === false && (!("CLUSTER_FORWARD_AVAILABLE" in variant.defines) || variant.defines.CLUSTER_FORWARD_AVAILABLE === hdrpRequested)
   );
@@ -22544,6 +22957,9 @@ function resolveMaterialShaderVariantSet(requestedVariantSet, variants, backendK
   const sorted = Object.entries(filtered).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
   return sorted.every(([, value]) => value) ? requestedVariantSet === "" ? "" : void 0 : sorted.map(([name, value]) => `${name}=${value}`).join("+");
 }
+function normalizeMaterialShaderVariantSet(requestedVariantSet, manifestEntry) {
+  return manifestEntry !== void 0 && manifestEntry.variants.length === 0 ? void 0 : requestedVariantSet;
+}
 async function createRenderer(canvas, options, bundler, backend) {
   const pack = backend ?? (options?.rhi === void 0 ? void 0 : loadRhiPack({ rhi: options.rhi, ...options.rhi }, options.rhiInstrumentation));
   if (pack === void 0) {
@@ -22594,20 +23010,20 @@ function attachDeviceLostFanout(device, pack, registries) {
         );
       }
     }
-  }).catch((err28) => {
+  }).catch((err29) => {
     pack.instrumentation?.onDeviceLost?.();
-    onDeviceLost?.(`device.lost rejected: ${String(err28)}`);
-    lostRegistry.fire({ reason: "unknown", message: String(err28) });
+    onDeviceLost?.(`device.lost rejected: ${String(err29)}`);
+    lostRegistry.fire({ reason: "unknown", message: String(err29) });
     healthRegistry.fire({
       reason: "device-lost",
-      detail: { lostReason: "unknown", message: String(err28) },
+      detail: { lostReason: "unknown", message: String(err29) },
       recoverable: true
     });
     errorRegistry.fire(
       new RhiError({
         code: "device-lost",
         expected: "device.lost Promise resolves with GPUDeviceLostInfo",
-        hint: `device.lost Promise rejected unexpectedly: ${String(err28)}`
+        hint: `device.lost Promise rejected unexpectedly: ${String(err29)}`
       })
     );
   });
@@ -23181,7 +23597,7 @@ async function makeWebGPURenderer(internals) {
     const resolvedUvSetCount = shaderUvSetCount ?? materialShaderUvSetCounts.get(materialShaderId);
     const manifestEntry = findMaterialShaderManifestEntry(materialShaderId);
     const resolvedVariantSet = resolveCachedMaterialShaderVariantSet(variantSet, manifestEntry);
-    let effectiveVariantSet = resolvedVariantSet;
+    let effectiveVariantSet = normalizeMaterialShaderVariantSet(resolvedVariantSet, manifestEntry);
     if (vertexLayoutProjection === void 0 && manifestEntry?.variants.some((variant) => "VERTEX_COLOR_AVAILABLE" in variant.defines)) {
       if (effectiveVariantSet === "") {
         const noColorVariant = manifestEntry.variants.find(
@@ -23573,6 +23989,7 @@ async function makeWebGPURenderer(internals) {
         features: Object.freeze(
           (internals.featureHost?.features ?? []).map((feature) => feature.identity)
         ),
+        featureDiagnostics: internals.featureHost?.diagnostics() ?? Object.freeze([]),
         frustumStats: Object.freeze({ ...renderSystem.frustumStats }),
         visibilityStats: Object.freeze({ ...renderSystem.visibilityStats }),
         renderScene: renderSystem.renderScene,
@@ -24356,6 +24773,13 @@ function exposeRenderer(renderer) {
     draw: (request) => {
       const result = renderer.drawFrame(request);
       if (!result.ok) return err(drawError(result.error));
+      emit(
+        Object.freeze({
+          kind: "frame-submitted",
+          frameId: result.value.frameId,
+          deviceGeneration: result.value.deviceGeneration
+        })
+      );
       return ok(result.value);
     },
     inspect: () => renderer.inspect(),
@@ -24989,6 +25413,24 @@ async function buildReadyWebGPU(rhiDevice, getShader, gpuStore, asyncCreateShade
         brdfLut: iblBrdfLutEntry.wgsl
       });
     }
+    const pointsLinesLookup = registry.findMaterialArtifact(POINTS_LINES_MATERIAL_SHADER_ID);
+    if (pointsLinesLookup.ok) {
+      const pointsLinesLabel = `module-${POINTS_LINES_MATERIAL_SHADER_ID}`;
+      const pointsLinesShaderResult = await runShimStep(
+        () => asyncCreateShaderModule ? asyncCreateShaderModule(rhiDevice, {
+          code: pointsLinesLookup.value.source,
+          label: pointsLinesLabel
+        }) : invokeDeviceCreateShaderModule(rhiDevice, {
+          code: pointsLinesLookup.value.source,
+          label: pointsLinesLabel
+        }),
+        "shader-compile-failed",
+        `engine material shader '${POINTS_LINES_MATERIAL_SHADER_ID}' compiled`,
+        `inspect the composed WGSL for '${POINTS_LINES_MATERIAL_SHADER_ID}' and check device.features`
+      );
+      if (!pointsLinesShaderResult.ok) throw pointsLinesShaderResult.error;
+      seedShaderModule(pointsLinesLabel, pointsLinesShaderResult.value);
+    }
     for (const materialShaderId of requiredMaterialShaders) {
       const lookup = registry.findMaterialArtifact(materialShaderId);
       if (!lookup.ok) {
@@ -25452,6 +25894,18 @@ async function buildReadyWebGPU(rhiDevice, getShader, gpuStore, asyncCreateShade
     "check device.limits.maxUniformBufferBindingSize"
   );
   if (!viewUboResult.ok) throw viewUboResult.error;
+  const pointsLinesViewBufferResult = runShimSyncStep(
+    () => rhiDevice.createBuffer({
+      label: "points-lines-view-ubo",
+      size: POINTS_LINES_VIEW_BUFFER_SIZE,
+      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+      mappedAtCreation: false
+    }),
+    "webgpu-runtime-error",
+    "createBuffer (points-lines view ubo) succeeded",
+    "check device.limits.maxUniformBufferBindingSize"
+  );
+  if (!pointsLinesViewBufferResult.ok) throw pointsLinesViewBufferResult.error;
   const shadowCasterCascadeUboResult = runShimSyncStep(
     () => rhiDevice.createBuffer({
       label: "shadow-caster-cascade-ubo",
@@ -25927,11 +26381,11 @@ async function buildReadyWebGPU(rhiDevice, getShader, gpuStore, asyncCreateShade
       }
       try {
         getOrBuildPipeline(spec, pipelineDeviceProvider, pipelineCache, modules);
-      } catch (err28) {
-        if (err28 instanceof PipelineSpecError) throw err28;
+      } catch (err29) {
+        if (err29 instanceof PipelineSpecError) throw err29;
         throw new PipelineSpecError({
           code: "pipeline-build-failed",
-          detail: { cause: err28 },
+          detail: { cause: err29 },
           hint: `Boot-time SPEC_CONST pre-warm failed for shader '${spec.shader.id}'; inspect gpuMessage on the cause`
         });
       }
@@ -26051,11 +26505,11 @@ async function buildReadyWebGPU(rhiDevice, getShader, gpuStore, asyncCreateShade
             pipelineCache,
             modules
           );
-        } catch (err28) {
-          if (err28 instanceof PipelineSpecError) throw err28;
+        } catch (err29) {
+          if (err29 instanceof PipelineSpecError) throw err29;
           throw new PipelineSpecError({
             code: "pipeline-build-failed",
-            detail: { cause: err28 },
+            detail: { cause: err29 },
             hint: "createRenderPipeline (fxaa fullscreen) failed; inspect gpuMessage"
           });
         }
@@ -26295,11 +26749,11 @@ async function buildReadyWebGPU(rhiDevice, getShader, gpuStore, asyncCreateShade
             pipelineCache,
             modules
           );
-        } catch (err28) {
-          if (err28 instanceof PipelineSpecError) throw err28;
+        } catch (err29) {
+          if (err29 instanceof PipelineSpecError) throw err29;
           throw new PipelineSpecError({
             code: "pipeline-build-failed",
-            detail: { cause: err28 },
+            detail: { cause: err29 },
             hint: "createRenderPipeline (bloom-bright fullscreen) failed; inspect gpuMessage"
           });
         }
@@ -26388,11 +26842,11 @@ async function buildReadyWebGPU(rhiDevice, getShader, gpuStore, asyncCreateShade
             pipelineCache,
             modules
           );
-        } catch (err28) {
-          if (err28 instanceof PipelineSpecError) throw err28;
+        } catch (err29) {
+          if (err29 instanceof PipelineSpecError) throw err29;
           throw new PipelineSpecError({
             code: "pipeline-build-failed",
-            detail: { cause: err28 },
+            detail: { cause: err29 },
             hint: "createRenderPipeline (bloom-blur-h fullscreen) failed; inspect gpuMessage"
           });
         }
@@ -26499,11 +26953,11 @@ async function buildReadyWebGPU(rhiDevice, getShader, gpuStore, asyncCreateShade
             pipelineCache,
             modules
           );
-        } catch (err28) {
-          if (err28 instanceof PipelineSpecError) throw err28;
+        } catch (err29) {
+          if (err29 instanceof PipelineSpecError) throw err29;
           throw new PipelineSpecError({
             code: "pipeline-build-failed",
-            detail: { cause: err28 },
+            detail: { cause: err29 },
             hint: "createRenderPipeline (bloom-composite fullscreen) failed; inspect gpuMessage"
           });
         }
@@ -26635,11 +27089,11 @@ async function buildReadyWebGPU(rhiDevice, getShader, gpuStore, asyncCreateShade
               pipelineCache,
               { ...baseModules, fragmentEntryPoint: "fs_ssao_calc" }
             );
-          } catch (err28) {
-            if (err28 instanceof PipelineSpecError) throw err28;
+          } catch (err29) {
+            if (err29 instanceof PipelineSpecError) throw err29;
             throw new PipelineSpecError({
               code: "pipeline-build-failed",
-              detail: { cause: err28 },
+              detail: { cause: err29 },
               hint: "createRenderPipeline (ssao-calc fullscreen) failed; inspect gpuMessage"
             });
           }
@@ -26670,11 +27124,11 @@ async function buildReadyWebGPU(rhiDevice, getShader, gpuStore, asyncCreateShade
               pipelineCache,
               { ...baseModules, fragmentEntryPoint: "fs_ssao_blur" }
             );
-          } catch (err28) {
-            if (err28 instanceof PipelineSpecError) throw err28;
+          } catch (err29) {
+            if (err29 instanceof PipelineSpecError) throw err29;
             throw new PipelineSpecError({
               code: "pipeline-build-failed",
-              detail: { cause: err28 },
+              detail: { cause: err29 },
               hint: "createRenderPipeline (ssao-blur fullscreen) failed; inspect gpuMessage"
             });
           }
@@ -26768,6 +27222,7 @@ async function buildReadyWebGPU(rhiDevice, getShader, gpuStore, asyncCreateShade
     materialBindGroupLayout: materialBglResult.value,
     meshBindGroupLayout: meshArrayBglResult.value,
     viewUniformBuffer: viewUboResult.value,
+    pointsLinesViewBuffer: pointsLinesViewBufferResult.value,
     shadowCasterCascadeBuffer: shadowCasterCascadeUboResult.value,
     // feat-20260608-mesh-ssbo-dynamic-grow-l1-lift-1024-entity-cap M2 /
     // T-M2-05: PipelineState now references the wrapper objects owned by