@forgeax/engine-render 0.1.4 → 0.1.7

package/dist/errors/render.d.ts

@@ -1,33 +1,23 @@
-import type { RenderFeatureCapabilityMissingDetail, RenderFeatureDrawRecordingFailedDetail, RenderFeaturePassOrderConflictDetail, RenderFeaturePreparationFailedDetail, RenderFeaturePreparedStateMismatchDetail, RenderFeatureRecovery, RenderFeatureRegistrationConflictDetail, RenderFeatureStage, RenderFeatureStageFailedDetail } from '../features/types';
-import type { MaterialRenderError } from '../renderer/material/pipeline-projection';
-/** Bounded identity facts for a resource-owner Fog cardinality conflict. */
-export interface FogOwnerConflictDetail {
-    readonly resourceOwner: number;
-    readonly entities: readonly number[];
-    readonly omitted: number;
-}
-/** The resource owner contains more than one Fog authoring entity. */
-export declare class FogOwnerConflictError extends Error {
-    readonly code: "fog-owner-conflict";
-    readonly expected = "resourceOwner contains zero or one Fog entity";
-    readonly hint = "remove every Fog entity except one from the resourceOwner World, then retry draw";
-    readonly detail: FogOwnerConflictDetail;
-    constructor(resourceOwner: number, entities: readonly number[], omitted: number);
-}
-/** Structured detail for one invalid Fog field. */
-export interface FogParametersInvalidDetail {
-    readonly entity: number;
-    readonly field: string;
-    readonly expected: string;
-    readonly actual: unknown;
-}
-/** A resource-owner Fog entity contains an invalid authored parameter. */
-export declare class FogParametersInvalidError extends Error {
-    readonly code: "fog-parameters-invalid";
-    readonly expected: string;
-    readonly hint: string;
-    readonly detail: FogParametersInvalidDetail;
-    constructor(entity: number, field: string, expected: string, actual: unknown);
+import type { DeviceResourceKind, DeviceScopeReceipt } from '../device/resource-types';
+import type { PreparedKind, RenderFeatureCapabilityKey, RenderFeatureRecovery, RenderFeatureStage } from '../features/vocabulary';
+export interface LifecycleConstructionFailureDetail {
+    readonly owner: string;
+    readonly generation: number;
+    readonly operation: 'create' | 'dispose';
+    readonly resourceKind: DeviceResourceKind;
+    readonly cause: unknown;
+    readonly cleanupFailures: readonly {
+        readonly resourceKind: DeviceResourceKind;
+        readonly cause: unknown;
+    }[];
+    readonly receipt: DeviceScopeReceipt;
+}
+export declare class LifecycleConstructionError extends Error {
+    readonly code: "lifecycle-construction-failed";
+    readonly expected = "all DeviceScope resources establish and terminate in order";
+    readonly hint = "inspect detail and cleanupFailures, then recover or rebuild the DeviceScope";
+    readonly detail: LifecycleConstructionFailureDetail;
+    constructor(detail: LifecycleConstructionFailureDetail);
 }
 /**
  * Detail for `RuntimeErrorCode 'shadow-invalid-config'`.
@@ -116,32 +106,6 @@ export declare class EquirectProjectionFailedError extends Error {
     readonly detail: EquirectProjectionFailedDetail;
     constructor(handle: number);
 }
-/**
- * Detail for `RuntimeErrorCode 'hdrp-caps-insufficient'`.
- *
- * Emitted at install time when `device.caps.maxStorageBuffersPerShaderStage < 4`.
- */
-export interface HdrpCapsInsufficientDetail {
-    readonly capName: string;
-    readonly actual: number;
-    readonly required: number;
-}
-/**
- * Structured error for HDRP storage-buffer capability gate failure (AC-17/AC-18).
- *
- * Emitted at `installPipeline(hdrpAsset)` time — synchronous throw.
- *   - `.code = 'hdrp-caps-insufficient'` (closed RuntimeErrorCode)
- *   - `.expected` — describes the required capability
- *   - `.hint` — 'fall back to URP by not calling installPipeline'
- *   - `.detail = { capName, actual, required }`
- */
-export declare class HdrpCapsInsufficientError extends Error {
-    readonly code: "hdrp-caps-insufficient";
-    readonly expected: string;
-    readonly hint: string;
-    readonly detail: HdrpCapsInsufficientDetail;
-    constructor(capName: string, actual: number, required: number);
-}
 /**
  * Detail for `RuntimeErrorCode 'hdrp-light-budget-exceeded'`.
  *
@@ -199,7 +163,7 @@ export declare class HdrpIndexListOverflowError extends Error {
 /**
  * Detail for `RuntimeErrorCode 'hdrp-deferred-caps-insufficient'`.
  *
- * Emitted at `installPipeline(hdrpAsset)` time when `device.caps.maxColorAttachments < 4`,
+ * Emitted when the Standard clustered lane has fewer than 4 color attachments,
  * meaning the deferred path cannot allocate 3 g-buffer color targets + depth.
  */
 export interface HdrpDeferredCapsInsufficientDetail {
@@ -209,13 +173,13 @@ export interface HdrpDeferredCapsInsufficientDetail {
 /**
  * Structured error for deferred-path capability gate failure.
  *
- * Emitted at `installPipeline(hdrpAsset)` time — synchronous throw.
+ * Emitted during Standard clustered lane validation — synchronous throw.
  *   - `.code = 'hdrp-deferred-caps-insufficient'` (closed RuntimeErrorCode)
  *   - `.expected` — 'maxColorAttachments >= 4'
  *   - `.hint` — actionable guidance to upgrade browser or select URP
  *   - `.detail = { actual, expected }`
  *
- * @see plan-strategy D-5 (install-time caps check, no silent fallback)
+ * @see plan-strategy D-5 (capability validation, no silent fallback)
  */
 export declare class HdrpDeferredCapsInsufficientError extends Error {
     readonly code: "hdrp-deferred-caps-insufficient";
@@ -224,65 +188,6 @@ export declare class HdrpDeferredCapsInsufficientError extends Error {
     readonly detail: HdrpDeferredCapsInsufficientDetail;
     constructor(actual: number);
 }
-/**
- * Detail for `RuntimeErrorCode 'gbuffer-rt-alloc-failed'`.
- *
- * Emitted at runtime when a g-buffer color target pool allocation fails
- * (OOM or backend resource limit). The attachmentIndex identifies which
- * g-buffer slot failed.
- */
-export interface GbufferRtAllocFailedDetail {
-    readonly attachmentIndex: number;
-    readonly requestedBytes: number;
-}
-/**
- * Structured error for g-buffer color-target pool allocation failure.
- *
- * Emitted at runtime during g-buffer pass setup.
- *   - `.code = 'gbuffer-rt-alloc-failed'` (closed RuntimeErrorCode)
- *   - `.expected` — 'g-buffer color target allocation succeeded'
- *   - `.hint` — actionable recovery steps (check GPU memory / reduce resolution)
- *   - `.detail = { attachmentIndex, requestedBytes }`
- *
- * @note This error is declared in M1 but only triggered in M2 (g-buffer RT
- *   allocation path). The union member exists for compile-time narrowing now.
- */
-export declare class GbufferRtAllocFailedError extends Error {
-    readonly code: "gbuffer-rt-alloc-failed";
-    readonly expected: string;
-    readonly hint: string;
-    readonly detail: GbufferRtAllocFailedDetail;
-    constructor(attachmentIndex: number, requestedBytes: number);
-}
-/**
- * Detail for `RuntimeErrorCode 'gbuffer-attachment-count-mismatch'`.
- *
- * Emitted at install-time when the g-buffer attachment count declared
- * in the pipeline schema does not equal 3.
- */
-export interface GbufferAttachmentCountMismatchDetail {
-    readonly actual: number;
-    readonly expected: number;
-}
-/**
- * Structured error for g-buffer attachment count mismatch.
- *
- * Emitted at `installPipeline(hdrpAsset)` time via topology validation.
- *   - `.code = 'gbuffer-attachment-count-mismatch'` (closed RuntimeErrorCode)
- *   - `.expected` — 'exactly 3 g-buffer color attachments'
- *   - `.hint` — check pipeline internal schema or custom g-buffer override
- *   - `.detail = { actual, expected }`
- *
- * @note This error is declared in M1 but only triggered in M2 (g-buffer
- *   topology validation). The union member exists for compile-time narrowing now.
- */
-export declare class GbufferAttachmentCountMismatchError extends Error {
-    readonly code: "gbuffer-attachment-count-mismatch";
-    readonly expected: string;
-    readonly hint: string;
-    readonly detail: GbufferAttachmentCountMismatchDetail;
-    constructor(actual: number);
-}
 /**
  * Structured error for `ShadowAtlas.faceView` called before `ensure()`
  * allocated the cube_array texture. Replaces the prior bare
@@ -367,6 +272,19 @@ export declare class VertexStorageBufferUnavailableError extends Error {
     readonly hint: string;
     constructor();
 }
+export interface VertexColorVariantConflictDetail {
+    readonly authored: true;
+    readonly authoredValue: string;
+    readonly projected: boolean;
+}
+/** The authored color axis disagrees with the canonical geometry projection. */
+export declare class VertexColorVariantConflictError extends Error {
+    readonly code: "vertex-color-variant-conflict";
+    readonly expected: string;
+    readonly hint: string;
+    readonly detail: VertexColorVariantConflictDetail;
+    constructor(authoredValue: string, projected: boolean);
+}
 /** Detail for a palette buffer that exceeds the device storage limit. */
 export interface SkinPaletteOverflowDetail {
     readonly requestedBytes: number;
@@ -411,6 +329,133 @@ export declare class MaterialSkinAttrMissingError extends Error {
     readonly detail: MaterialSkinAttrMissingDetail;
     constructor(entity: number, missing: 'skinIndex' | 'skinWeight' | 'both');
 }
+export type RenderFeatureErrorCode = 'render-feature-registration-conflict' | 'render-feature-stage-failed' | 'render-feature-capability-missing' | 'render-feature-pass-order-conflict' | 'render-feature-preparation-failed' | 'render-feature-prepared-state-mismatch' | 'render-feature-draw-recording-failed';
+export interface RenderFeatureRegistrationConflictDetail {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly conflictingOrder: number;
+}
+export interface RenderFeatureCleanupFailure {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly code: string;
+}
+export interface RenderFeatureStageFailedDetail {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly stage: RenderFeatureStage;
+    readonly recovery: RenderFeatureRecovery;
+    readonly cleanupFailures?: readonly RenderFeatureCleanupFailure[];
+}
+export interface RenderFeatureCapabilityMissingDetail {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly capability: RenderFeatureCapabilityKey;
+}
+export interface RenderFeaturePassOrderConflictDetail {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly passIdentity: string;
+    readonly dependencyIdentity: string;
+}
+export interface RenderFeaturePreparationFailedDetail {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly stage: 'prepare';
+    readonly operation: string;
+    readonly resourceKind: PreparedKind;
+    readonly resourceName: string;
+    readonly reason: string;
+    readonly recovery: RenderFeatureRecovery;
+}
+export type RenderFeaturePreparedStateMismatchDetail = {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly stage: 'contribute';
+    readonly operation: string;
+    readonly resourceKind: PreparedKind;
+    readonly reason: 'missing-prepared-state';
+    readonly missingResource: string;
+    readonly recovery: RenderFeatureRecovery;
+} | {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly stage: 'contribute';
+    readonly operation: string;
+    readonly resourceKind: PreparedKind;
+    readonly reason: 'foreign-feature';
+    readonly expectedFeatureIdentity: string;
+    readonly actualFeatureIdentity: string;
+    readonly recovery: RenderFeatureRecovery;
+} | {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly stage: 'contribute';
+    readonly operation: string;
+    readonly resourceKind: PreparedKind;
+    readonly reason: 'foreign-kind';
+    readonly expectedKind: PreparedKind;
+    readonly actualKind: PreparedKind;
+    readonly recovery: RenderFeatureRecovery;
+} | {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly stage: 'contribute';
+    readonly operation: string;
+    readonly resourceKind: PreparedKind;
+    readonly reason: 'generation-mismatch';
+    readonly expectedGeneration: number;
+    readonly actualGeneration: number;
+    readonly recovery: RenderFeatureRecovery;
+} | {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly stage: 'contribute';
+    readonly operation: string;
+    readonly resourceKind: PreparedKind;
+    readonly reason: 'layout-mismatch';
+    readonly expectedLayout: string;
+    readonly actualLayout: string;
+    readonly recovery: RenderFeatureRecovery;
+} | {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly stage: 'contribute';
+    readonly operation: string;
+    readonly resourceKind: PreparedKind;
+    readonly reason: 'format-mismatch';
+    readonly expectedFormat: string;
+    readonly actualFormat: string;
+    readonly recovery: RenderFeatureRecovery;
+};
+export interface RenderFeatureDrawRecordingFailedDetail {
+    readonly featureIdentity: string;
+    readonly order: number;
+    readonly stage: 'record';
+    readonly operation: string;
+    readonly resourceKind: PreparedKind;
+    readonly reason: string;
+    readonly backendReason: string;
+    readonly recovery: RenderFeatureRecovery;
+}
+export type RenderFeatureErrorDetailByCode = {
+    'render-feature-registration-conflict': RenderFeatureRegistrationConflictDetail;
+    'render-feature-stage-failed': RenderFeatureStageFailedDetail;
+    'render-feature-capability-missing': RenderFeatureCapabilityMissingDetail;
+    'render-feature-pass-order-conflict': RenderFeaturePassOrderConflictDetail;
+    'render-feature-preparation-failed': RenderFeaturePreparationFailedDetail;
+    'render-feature-prepared-state-mismatch': RenderFeaturePreparedStateMismatchDetail;
+    'render-feature-draw-recording-failed': RenderFeatureDrawRecordingFailedDetail;
+};
+/** Machine-readable four-field diagnostic exposed by every feature error. */
+export type RenderFeatureErrorDescriptor = {
+    [Code in RenderFeatureErrorCode]: {
+        readonly code: Code;
+        readonly expected: string;
+        readonly hint: string;
+        readonly detail: RenderFeatureErrorDetailByCode[Code];
+    };
+}[RenderFeatureErrorCode];
 export declare class RenderFeatureRegistrationConflictError extends Error {
     readonly code: "render-feature-registration-conflict";
     readonly expected: string;
@@ -473,152 +518,179 @@ export declare class ObservationUnavailableError extends Error {
     readonly detail: ObservationUnavailableDetail;
     constructor(reason: ObservationUnavailableReason, hint: string);
 }
-export interface TaaCapsInsufficientDetail {
-    readonly rgba16floatRenderable: boolean;
-    readonly maxColorAttachments: number;
-    readonly recovery: 'enable-temporal-capabilities';
-}
-/** The active device cannot support the renderer-owned temporal attachments. */
-export declare class TaaCapsInsufficientError extends Error {
-    readonly code: "taa-caps-insufficient";
-    readonly expected = "rgba16floatRenderable and maxColorAttachments >= 2";
-    readonly hint = "select a device with rgba16float render targets and at least two color attachments, then rebuild the renderer";
-    readonly detail: TaaCapsInsufficientDetail;
-    constructor(rgba16floatRenderable: boolean, maxColorAttachments: number);
-}
-export type TemporalUnsupportedReason = 'resolve-count' | 'scene-color-domain' | 'scene-color-sample-count' | 'scene-depth-sample-count' | 'temporal-attachment-missing' | 'temporal-attachment-format' | 'temporal-attachment-sample-count' | 'resolve-resources-missing' | 'resolve-frame-missing';
-export interface TemporalUnsupportedDetail {
-    readonly reason: TemporalUnsupportedReason;
-    readonly actual: string;
-    readonly recovery: 'fix-temporal-pipeline-topology';
-}
-/** A pipeline violated the single renderer-owned temporal resolve seam. */
-export declare class TemporalUnsupportedError extends Error {
-    readonly code: "temporal-unsupported";
+export interface FrameReceiptStaleDetail {
+    readonly frameId: number;
+    readonly receiptGeneration: number;
+    readonly currentGeneration: number;
+}
+/** Receipt-bound observation failed closed at a generation fence. */
+export declare class FrameReceiptStaleError extends Error {
+    readonly code: "frame-receipt-stale";
+    readonly expected = "the observation receipt belongs to the active device generation";
+    readonly hint = "draw a new frame and call observe with its returned FrameReceipt";
+    readonly detail: FrameReceiptStaleDetail;
+    constructor(detail: FrameReceiptStaleDetail);
+}
+export interface RendererContractFailureDetail {
+    readonly operation: 'construct' | 'attach' | 'draw' | 'observe';
+    readonly cause: string;
+}
+/** Structured boundary failure while adapting an owner contract. */
+export declare class RendererContractFailureError extends Error {
+    readonly code: "renderer-contract-failed";
+    readonly expected = "renderer owner contracts remain valid at the public boundary";
+    readonly hint = "repair the owner contract and retry the operation";
+    readonly detail: RendererContractFailureDetail;
+    constructor(operation: RendererContractFailureDetail['operation'], cause: string);
+}
+export interface RendererOperationCause {
+    readonly code: string;
     readonly expected: string;
-    readonly hint = "call resolveTemporal exactly once after temporal raster and pass single-sample rgba16float scene and temporal targets";
-    readonly detail: TemporalUnsupportedDetail;
-    constructor(reason: TemporalUnsupportedReason, expected: string, actual: string);
+    readonly hint: string;
+    readonly detail?: unknown;
 }
-export type AtmosphereField = 'turbidity' | 'rayleigh' | 'mieCoefficient' | 'mieDirectionalG' | 'sunAngularRadius';
-export interface AtmosphereParameterInvalidDetail {
-    readonly field: AtmosphereField;
-    readonly value: number;
-    readonly min: number;
-    readonly max: number;
-    readonly minExclusive: boolean;
+export interface RendererOperationDetailByCode {
+    readonly 'world-lease-invalid': {
+        readonly operation: 'attach' | 'draw';
+        readonly cause: RendererOperationCause;
+    };
+    readonly 'frame-input-invalid': {
+        readonly operation: 'draw' | 'set-profile';
+        readonly cause: RendererOperationCause;
+    };
+    readonly 'scene-projection-failed': {
+        readonly operation: 'draw';
+        readonly cause: RendererOperationCause;
+    };
+    readonly 'asset-binding-failed': {
+        readonly operation: 'draw';
+        readonly cause: RendererOperationCause;
+    };
+    readonly 'feature-plan-failed': {
+        readonly operation: 'draw';
+        readonly cause: RendererOperationCause;
+    };
+    readonly 'graph-build-failed': {
+        readonly operation: 'draw' | 'set-profile';
+        readonly cause: RendererOperationCause;
+    };
+    readonly 'device-operation-failed': {
+        readonly operation: 'draw' | 'complete-frame' | 'renderer-event';
+        readonly frameId?: number;
+        readonly deviceGeneration?: number;
+        readonly cause: RendererOperationCause;
+    };
+    readonly 'surface-unavailable': {
+        readonly operation: 'release-surface' | 'restore-surface';
+        readonly cause: RendererOperationCause;
+    };
+    readonly 'renderer-state-invalid': {
+        readonly operation: 'draw' | 'set-profile' | 'recover' | 'dispose';
+        readonly state: string;
+        readonly cause?: RendererOperationCause;
+    };
+    readonly 'recovery-failed': {
+        readonly operation: 'recover';
+        readonly oldGeneration: number;
+        readonly cause: RendererOperationCause;
+    };
+    readonly 'cleanup-failed': {
+        readonly operation: 'dispose';
+        readonly causes: readonly RendererOperationCause[];
+    };
 }
-/** A finite Atmosphere field is outside its authoring range. */
-export declare class AtmosphereParameterInvalidError extends Error {
-    readonly code: "atmosphere-parameter-invalid";
+export type RendererOperationErrorCode = keyof RendererOperationDetailByCode;
+/** Public renderer-operation failure with a code-narrowed structured detail. */
+export declare class RendererOperationError<Code extends RendererOperationErrorCode> extends Error {
+    readonly code: Code;
     readonly expected: string;
     readonly hint: string;
-    readonly detail: AtmosphereParameterInvalidDetail;
-    constructor(field: AtmosphereField, value: number, min: number, max: number, minExclusive?: boolean);
-}
-export interface AtmosphereCardinalityInvalidDetail {
-    readonly count: number;
-    readonly max: 1;
-    readonly entities: readonly number[];
-}
-/** More than one Atmosphere authoring component exists in one resource World. */
-export declare class AtmosphereCardinalityInvalidError extends Error {
-    readonly code: "atmosphere-cardinality-invalid";
-    readonly expected = "exactly one Atmosphere component in the resourceOwner World";
-    readonly hint = "remove extra Atmosphere entities and keep one analytic source";
-    readonly detail: AtmosphereCardinalityInvalidDetail;
-    constructor(count: number, entities: readonly number[]);
-}
-export interface AtmosphereSunMissingDetail {
-    readonly atmosphereEntity: number;
-}
-/** An Atmosphere entity is not a Sun unless its same entity carries DirectionalLight. */
-export declare class AtmosphereSunMissingError extends Error {
-    readonly code: "atmosphere-sun-missing";
-    readonly expected = "Atmosphere and DirectionalLight share one entity";
-    readonly hint = "add a valid DirectionalLight to the Atmosphere entity";
-    readonly detail: AtmosphereSunMissingDetail;
-    constructor(atmosphereEntity: number);
-}
-export interface EnvironmentSourceConflictDetail {
-    readonly atmosphereEntities: readonly number[];
-    readonly imageEntities: readonly number[];
-}
-/** Image and analytic environment facts cannot silently choose a precedence. */
-export declare class EnvironmentSourceConflictError extends Error {
-    readonly code: "environment-source-conflict";
-    readonly expected = "exactly one image or atmosphere environment source";
-    readonly hint = "remove either the image environment or the Atmosphere source";
-    readonly detail: EnvironmentSourceConflictDetail;
-    constructor(atmosphereEntities: readonly number[], imageEntities: readonly number[]);
-}
-export interface AtmosphereCapsInsufficientDetail {
-    readonly capability: string;
-    readonly actual: boolean | number;
-    readonly required: boolean | number;
-}
-/** The selected device cannot render the required HDR atmosphere resources. */
-export declare class AtmosphereCapsInsufficientError extends Error {
-    readonly code: "atmosphere-caps-insufficient";
+    readonly detail: RendererOperationDetailByCode[Code];
+    constructor(code: Code, detail: RendererOperationDetailByCode[Code]);
+}
+export type RendererExpectedOperationError = {
+    readonly [Code in RendererOperationErrorCode]: RendererOperationError<Code>;
+}[RendererOperationErrorCode];
+export interface PointsLinesInvalidStyleDetail {
+    readonly entity: number;
+    readonly component: 'Points' | 'Lines' | 'Points/Lines';
+    readonly field: string;
+    readonly value: number | string | undefined;
     readonly expected: string;
-    readonly hint = "select a backend with the required HDR render and sample capabilities";
-    readonly detail: AtmosphereCapsInsufficientDetail;
-    constructor(capability: string, actual: boolean | number, required: boolean | number);
 }
-export interface AtmosphereProducerFailedDetail {
-    readonly stage: 'build' | 'execute' | 'submit';
-    readonly reason: string;
-    readonly generation?: number;
+export declare class PointsLinesInvalidStyleError extends Error {
+    readonly code: "points-lines-invalid-style";
+    readonly expected: string;
+    readonly hint: string;
+    readonly detail: PointsLinesInvalidStyleDetail;
+    constructor(detail: PointsLinesInvalidStyleDetail);
 }
-/** The candidate atmosphere producer did not complete atomically. */
-export declare class AtmosphereProducerFailedError extends Error {
-    readonly code: "atmosphere-producer-failed";
-    readonly expected = "candidate atmosphere generation builds, executes, and submits atomically";
-    readonly hint = "retain the last-known-good generation, inspect the stage, and retry after repair";
-    readonly detail: AtmosphereProducerFailedDetail;
-    constructor(stage: AtmosphereProducerFailedDetail['stage'], reason: string, generation?: number);
+export interface PointsLinesTopologyMismatchDetail {
+    readonly entity: number;
+    readonly submesh: number;
+    readonly expected: string;
+    readonly actual: string;
 }
-/**
- * Render-owned projection of a failed material readiness result.
- *
- * The readiness owner supplies the structured fields; render adds only the
- * stable draw dedupe key. This is a diagnostic fact, not a second error or
- * material registry.
- */
-export interface MaterialDrawDiagnostic {
-    readonly key: string;
-    readonly code: MaterialRenderError['error']['code'];
-    readonly materialGuid: string;
-    readonly specializationKey: string;
-    readonly publicationGeneration?: number;
+export declare class PointsLinesTopologyMismatchError extends Error {
+    readonly code: "points-lines-topology-mismatch";
     readonly expected: string;
-    readonly actual?: string;
     readonly hint: string;
-    readonly retryable: boolean;
-    readonly recoveryActions: readonly string[];
+    readonly detail: PointsLinesTopologyMismatchDetail;
+    constructor(detail: PointsLinesTopologyMismatchDetail);
 }
-export declare function materialDrawDiagnostic(error: MaterialRenderError): MaterialDrawDiagnostic;
-export declare class MeshSsboCeilingReachedError extends Error {
-    readonly code: "mesh-ssbo-ceiling-reached";
+export interface PointsLinesStyleUnsupportedDetail {
+    readonly lane: string;
+    readonly field: string;
+    readonly member: string;
+    readonly supported: readonly string[];
+}
+export declare class PointsLinesStyleUnsupportedError extends Error {
+    readonly code: "points-lines-style-unsupported";
     readonly expected: string;
     readonly hint: string;
-    readonly detail: {
-        readonly requested: number;
-        readonly capacity: number;
-        readonly ceiling: number;
-    };
-    constructor(requested: number, capacity: number, ceiling: number);
+    readonly detail: PointsLinesStyleUnsupportedDetail;
+    constructor(detail: PointsLinesStyleUnsupportedDetail);
+}
+export interface PointsLinesMaterialUnsupportedDetail {
+    readonly entity: number;
+    readonly material: string;
+    readonly pass: string;
+    readonly module: string;
+    readonly reason: string;
 }
-export declare class MeshSsboCapacityExceededError extends Error {
-    readonly code: "mesh-ssbo-capacity-exceeded";
+export declare class PointsLinesMaterialUnsupportedError extends Error {
+    readonly code: "points-lines-material-unsupported";
+    readonly expected = "one engine-owned unlit forward MaterialAsset pass";
+    readonly hint: string;
+    readonly detail: PointsLinesMaterialUnsupportedDetail;
+    constructor(detail: PointsLinesMaterialUnsupportedDetail);
+}
+export interface PointsLinesBudgetExceededDetail {
+    readonly lane: string;
+    readonly requested: number;
+    readonly limit: number;
+    readonly unit: 'points' | 'segments' | 'vertices' | 'indices' | 'bytes' | 'draws';
+}
+export declare class PointsLinesBudgetExceededError extends Error {
+    readonly code: "points-lines-budget-exceeded";
     readonly expected: string;
     readonly hint: string;
-    readonly detail: {
-        readonly requested: number;
-        readonly capacity: number;
-        readonly ceiling: number;
-    };
-    constructor(requested: number, capacity: number, ceiling: number);
+    readonly detail: PointsLinesBudgetExceededDetail;
+    constructor(detail: PointsLinesBudgetExceededDetail);
+}
+export interface PointsLinesPrepareFailedDetail {
+    readonly owner: string;
+    readonly generation: number;
+    readonly stage: 'prepare';
+    readonly cause: string;
+    readonly lastKnownGood: boolean;
+}
+export declare class PointsLinesPrepareFailedError extends Error {
+    readonly code: "points-lines-prepare-failed";
+    readonly expected = "the complete Points/Lines candidate validates before publication";
+    readonly hint: string;
+    readonly detail: PointsLinesPrepareFailedDetail;
+    constructor(detail: PointsLinesPrepareFailedDetail);
 }
 /**
  * Closed union of render-cluster error codes. AI users perform exhaustive
@@ -629,5 +701,5 @@ export type RenderErrorCode = RenderError['code'];
  * Closed union of the render-cluster structured error classes, each carrying a
  * `RenderErrorCode` discriminant on `.code`.
  */
-export type RenderError = FogOwnerConflictError | FogParametersInvalidError | ObservationUnavailableError | TaaCapsInsufficientError | TemporalUnsupportedError | AtmosphereCardinalityInvalidError | AtmosphereSunMissingError | EnvironmentSourceConflictError | AtmosphereParameterInvalidError | AtmosphereCapsInsufficientError | AtmosphereProducerFailedError | ShadowInvalidConfigError | EquirectProjectionFailedError | HdrpCapsInsufficientError | HdrpLightBudgetExceededError | HdrpIndexListOverflowError | HdrpDeferredCapsInsufficientError | GbufferRtAllocFailedError | GbufferAttachmentCountMismatchError | PointShadowAtlasUninitializedError | PointShadowAtlasBoundsViolationError | VideoUploadUnsupportedError | VertexStorageBufferUnavailableError | SkinPaletteOverflowError | SkinMaterialMismatchError | MaterialSkinAttrMissingError | RenderFeatureRegistrationConflictError | RenderFeatureStageFailedError | RenderFeatureCapabilityMissingError | RenderFeaturePassOrderConflictError | RenderFeaturePreparationFailedError | RenderFeaturePreparedStateMismatchError | RenderFeatureDrawRecordingFailedError;
+export type RenderError = LifecycleConstructionError | RendererExpectedOperationError | FrameReceiptStaleError | RendererContractFailureError | ObservationUnavailableError | ShadowInvalidConfigError | EquirectProjectionFailedError | HdrpLightBudgetExceededError | HdrpIndexListOverflowError | HdrpDeferredCapsInsufficientError | PointShadowAtlasUninitializedError | PointShadowAtlasBoundsViolationError | VideoUploadUnsupportedError | VertexStorageBufferUnavailableError | VertexColorVariantConflictError | SkinPaletteOverflowError | SkinMaterialMismatchError | MaterialSkinAttrMissingError | RenderFeatureRegistrationConflictError | RenderFeatureStageFailedError | RenderFeatureCapabilityMissingError | RenderFeaturePassOrderConflictError | RenderFeaturePreparationFailedError | RenderFeaturePreparedStateMismatchError | RenderFeatureDrawRecordingFailedError | PointsLinesInvalidStyleError | PointsLinesTopologyMismatchError | PointsLinesStyleUnsupportedError | PointsLinesMaterialUnsupportedError | PointsLinesBudgetExceededError | PointsLinesPrepareFailedError;
 //# sourceMappingURL=render.d.ts.map