@carbonenginejs/runtime-resource 0.12.0 → 0.12.1

package/dist/resource/texture/CjsTextureArrayRes.js

@@ -1,11 +1,8 @@
-import { identity as _identity, applyDecs2311 as _applyDecs2311 } from '../../_virtual/_rollupPluginBabelHelpers.js';
-import { type } from '@carbonenginejs/runtime-utils/schema';
+import { CjsSchema } from '@carbonenginejs/runtime-utils/schema';
 import { normalizeResourcePath } from '@carbonenginejs/runtime-utils/path';
-import { CjsResource as _CjsResource } from '../CjsResource.js';
+import { CjsResource } from '../CjsResource.js';
 import { CjsTextureArrayResParameterProxy } from './CjsTextureArrayResParameterProxy.js';
 
-let _initClass;
-
 /**
  * Mutable runtime aggregate for an ordered texture-array request.
  *
@@ -13,471 +10,463 @@ let _initClass;
  * manager or engine scheduler consumes the coalesced update on a later frame
  * and prepares the corresponding immutable/cached texture-array payload.
  */
-let _CjsTextureArrayRes;
-new class extends _identity {
-  static [class CjsTextureArrayRes extends _CjsResource {
-    static {
-      [_CjsTextureArrayRes, _initClass] = _applyDecs2311(this, [type.define({
-        className: "CjsTextureArrayRes",
-        family: "resource"
-      })], [], 0, void 0, _CjsResource).c;
-    }
-    #layers = [];
-    #dirtyLayers = new Set();
-    #requestedRevision = 0;
-    #preparedRevision = 0;
-    #updateScheduled = false;
-    #topologyChanged = false;
-    #inFlightRequests = new Map();
-    #readyWaiters = [];
-    #failedRevision = 0;
-    #failedError = null;
-    #updateScheduler = null;
-    #updateHandler = null;
-
-    /** Creates a CjsTextureArrayRes with caller-provided initial state. */
-    constructor(values = null) {
-      const options = values && typeof values === "object" && !Array.isArray(values) ? values : {};
-      const resourceValues = {
-        ...options
-      };
-      delete resourceValues.layers;
-      delete resourceValues.paths;
-      delete resourceValues.layerCount;
-      delete resourceValues.layerNames;
-      delete resourceValues.updateScheduler;
-      delete resourceValues.updateHandler;
-      super(resourceValues);
-      if (options.updateScheduler) this.SetUpdateScheduler(options.updateScheduler);
-      if (options.updateHandler) this.SetUpdateHandler(options.updateHandler);
-      const paths = options.layers || options.paths;
-      if (paths !== undefined) {
-        this.SetLayerResourcePaths(paths, options.layerNames);
-      } else if (options.layerCount !== undefined) {
-        this.SetLayerCount(options.layerCount, options.layerNames);
-      }
+class CjsTextureArrayRes extends CjsResource {
+  #layers = [];
+  #dirtyLayers = new Set();
+  #requestedRevision = 0;
+  #preparedRevision = 0;
+  #updateScheduled = false;
+  #topologyChanged = false;
+  #inFlightRequests = new Map();
+  #readyWaiters = [];
+  #failedRevision = 0;
+  #failedError = null;
+  #updateScheduler = null;
+  #updateHandler = null;
+
+  /** Creates a CjsTextureArrayRes with caller-provided initial state. */
+  constructor(values = null) {
+    const options = values && typeof values === "object" && !Array.isArray(values) ? values : {};
+    const resourceValues = {
+      ...options
+    };
+    delete resourceValues.layers;
+    delete resourceValues.paths;
+    delete resourceValues.layerCount;
+    delete resourceValues.layerNames;
+    delete resourceValues.updateScheduler;
+    delete resourceValues.updateHandler;
+    super(resourceValues);
+    if (options.updateScheduler) this.SetUpdateScheduler(options.updateScheduler);
+    if (options.updateHandler) this.SetUpdateHandler(options.updateHandler);
+    const paths = options.layers || options.paths;
+    if (paths !== undefined) {
+      this.SetLayerResourcePaths(paths, options.layerNames);
+    } else if (options.layerCount !== undefined) {
+      this.SetLayerCount(options.layerCount, options.layerNames);
     }
+  }
 
-    /** Returns layer count from the current texture-array resource. */
-    GetLayerCount() {
-      return this.#layers.length;
-    }
+  /** Returns layer count from the current texture-array resource. */
+  GetLayerCount() {
+    return this.#layers.length;
+  }
 
-    /** Updates layer count in the current texture-array resource. */
-    SetLayerCount(value, names = null) {
-      const count = Number(value);
-      if (!Number.isInteger(count) || count < 1) {
-        throw new RangeError("CjsTextureArrayRes layer count must be a positive integer.");
-      }
-      if (count === this.#layers.length) {
-        this.#SetLayerNames(names);
-        return false;
-      }
-      const previousCount = this.#layers.length;
-      if (count < previousCount) {
-        this.#layers.length = count;
-      } else {
-        for (let layer = previousCount; layer < count; layer++) {
-          this.#layers.push(this.#CreateLayer(layer, names?.[layer]));
-        }
-      }
+  /** Updates layer count in the current texture-array resource. */
+  SetLayerCount(value, names = null) {
+    const count = Number(value);
+    if (!Number.isInteger(count) || count < 1) {
+      throw new RangeError("CjsTextureArrayRes layer count must be a positive integer.");
+    }
+    if (count === this.#layers.length) {
       this.#SetLayerNames(names);
-      this.#InvalidateRange(count, true);
-      return true;
+      return false;
+    }
+    const previousCount = this.#layers.length;
+    if (count < previousCount) {
+      this.#layers.length = count;
+    } else {
+      for (let layer = previousCount; layer < count; layer++) {
+        this.#layers.push(this.#CreateLayer(layer, names?.[layer]));
+      }
     }
+    this.#SetLayerNames(names);
+    this.#InvalidateRange(count, true);
+    return true;
+  }
 
-    /** Returns layer parameter from the current texture-array resource. */
-    GetLayerParameter(layer) {
-      return this.#GetLayer(layer).proxy;
-    }
+  /** Returns layer parameter from the current texture-array resource. */
+  GetLayerParameter(layer) {
+    return this.#GetLayer(layer).proxy;
+  }
 
-    /** Returns layer parameters from the current texture-array resource. */
-    GetLayerParameters(out = []) {
-      for (const layer of this.#layers) out.push(layer.proxy);
-      return out;
-    }
+  /** Returns layer parameters from the current texture-array resource. */
+  GetLayerParameters(out = []) {
+    for (const layer of this.#layers) out.push(layer.proxy);
+    return out;
+  }
 
-    /** Returns layer resource path from the current texture-array resource. */
-    GetLayerResourcePath(layer) {
-      return this.#GetLayer(layer).path;
-    }
+  /** Returns layer resource path from the current texture-array resource. */
+  GetLayerResourcePath(layer) {
+    return this.#GetLayer(layer).path;
+  }
 
-    /** Returns layer resource paths from the current texture-array resource. */
-    GetLayerResourcePaths(out = []) {
-      for (const layer of this.#layers) out.push(layer.path);
-      return out;
-    }
+  /** Returns layer resource paths from the current texture-array resource. */
+  GetLayerResourcePaths(out = []) {
+    for (const layer of this.#layers) out.push(layer.path);
+    return out;
+  }
 
-    /** Updates layer resource path in the current texture-array resource. */
-    SetLayerResourcePath(layer, value) {
-      const record = this.#GetLayer(layer);
-      const path = normalizeResourcePath(value);
-      if (path === record.path) return false;
-      record.path = path;
-      record.resource = null;
-      this.#InvalidateLayer(layer);
-      return true;
-    }
+  /** Updates layer resource path in the current texture-array resource. */
+  SetLayerResourcePath(layer, value) {
+    const record = this.#GetLayer(layer);
+    const path = normalizeResourcePath(value);
+    if (path === record.path) return false;
+    record.path = path;
+    record.resource = null;
+    this.#InvalidateLayer(layer);
+    return true;
+  }
 
-    /** Updates layer resource paths in the current texture-array resource. */
-    SetLayerResourcePaths(values, names = null) {
-      if (!Array.isArray(values) || values.length === 0) {
-        throw new TypeError("CjsTextureArrayRes layers must be a non-empty array of resource paths.");
-      }
-      const paths = values.map(value => normalizeResourcePath(value && typeof value === "object" ? value.resourcePath ?? value.path ?? value.GetPath?.() ?? "" : value));
-      const topologyChanged = paths.length !== this.#layers.length;
-      let contentChanged = topologyChanged;
-      let namesChanged = false;
-      const changedLayers = new Set();
-      const next = [];
-      for (let layer = 0; layer < paths.length; layer++) {
-        const current = this.#layers[layer];
-        const name = names?.[layer] ?? current?.proxy?.GetParameterName?.() ?? "";
-        if (!current) {
-          next.push(this.#CreateLayer(layer, name, paths[layer]));
-        } else {
-          if (current.path !== paths[layer]) {
-            current.path = paths[layer];
-            current.resource = null;
-            contentChanged = true;
-            changedLayers.add(layer);
-          }
-          if (current.proxy.SetParameterName(name)) namesChanged = true;
-          next.push(current);
+  /** Updates layer resource paths in the current texture-array resource. */
+  SetLayerResourcePaths(values, names = null) {
+    if (!Array.isArray(values) || values.length === 0) {
+      throw new TypeError("CjsTextureArrayRes layers must be a non-empty array of resource paths.");
+    }
+    const paths = values.map(value => normalizeResourcePath(value && typeof value === "object" ? value.resourcePath ?? value.path ?? value.GetPath?.() ?? "" : value));
+    const topologyChanged = paths.length !== this.#layers.length;
+    let contentChanged = topologyChanged;
+    let namesChanged = false;
+    const changedLayers = new Set();
+    const next = [];
+    for (let layer = 0; layer < paths.length; layer++) {
+      const current = this.#layers[layer];
+      const name = names?.[layer] ?? current?.proxy?.GetParameterName?.() ?? "";
+      if (!current) {
+        next.push(this.#CreateLayer(layer, name, paths[layer]));
+      } else {
+        if (current.path !== paths[layer]) {
+          current.path = paths[layer];
+          current.resource = null;
+          contentChanged = true;
+          changedLayers.add(layer);
         }
+        if (current.proxy.SetParameterName(name)) namesChanged = true;
+        next.push(current);
       }
-      this.#layers = next;
-      if (topologyChanged) {
-        this.#InvalidateRange(paths.length, true);
-      } else if (contentChanged) {
-        this.#InvalidateLayers(changedLayers);
-      }
-      return contentChanged || namesChanged;
     }
-
-    /** Returns layer resource from the current texture-array resource. */
-    GetLayerResource(layer) {
-      return this.#GetLayer(layer).resource;
+    this.#layers = next;
+    if (topologyChanged) {
+      this.#InvalidateRange(paths.length, true);
+    } else if (contentChanged) {
+      this.#InvalidateLayers(changedLayers);
     }
+    return contentChanged || namesChanged;
+  }
 
-    /** Updates layer resource in the current texture-array resource. */
-    SetLayerResource(layer, resource) {
-      const record = this.#GetLayer(layer);
-      const next = resource ?? null;
-      if (record.resource === next) return false;
-      record.resource = next;
-      this.#InvalidateLayer(layer);
-      return true;
-    }
+  /** Returns layer resource from the current texture-array resource. */
+  GetLayerResource(layer) {
+    return this.#GetLayer(layer).resource;
+  }
 
-    /** Invalidate a layer whose resolved resource changed without changing identity. */
-    TouchLayer(layer) {
-      this.#GetLayer(layer);
-      this.#InvalidateLayer(layer);
-      return this;
-    }
+  /** Updates layer resource in the current texture-array resource. */
+  SetLayerResource(layer, resource) {
+    const record = this.#GetLayer(layer);
+    const next = resource ?? null;
+    if (record.resource === next) return false;
+    record.resource = next;
+    this.#InvalidateLayer(layer);
+    return true;
+  }
 
-    /** Invalidate every current layer, for example after an adapter generation loss. */
-    TouchAllLayers(options = {}) {
-      this.#InvalidateRange(this.#layers.length, !!options.topologyChanged);
-      return this;
-    }
+  /** Invalidate a layer whose resolved resource changed without changing identity. */
+  TouchLayer(layer) {
+    this.#GetLayer(layer);
+    this.#InvalidateLayer(layer);
+    return this;
+  }
 
-    /** Returns requested revision from the current texture-array resource. */
-    GetRequestedRevision() {
-      return this.#requestedRevision;
-    }
+  /** Invalidate every current layer, for example after an adapter generation loss. */
+  TouchAllLayers(options = {}) {
+    this.#InvalidateRange(this.#layers.length, !!options.topologyChanged);
+    return this;
+  }
 
-    /** Returns prepared revision from the current texture-array resource. */
-    GetPreparedRevision() {
-      return this.#preparedRevision;
-    }
+  /** Returns requested revision from the current texture-array resource. */
+  GetRequestedRevision() {
+    return this.#requestedRevision;
+  }
 
-    /** Reports whether update is required by the current texture-array resource. */
-    NeedsUpdate() {
-      return this.#updateScheduled || this.#dirtyLayers.size > 0 || this.#preparedRevision < this.#requestedRevision;
-    }
+  /** Returns prepared revision from the current texture-array resource. */
+  GetPreparedRevision() {
+    return this.#preparedRevision;
+  }
 
-    /** Returns dirty layers from the current texture-array resource. */
-    GetDirtyLayers() {
-      return new Set(this.#dirtyLayers);
-    }
+  /** Reports whether update is required by the current texture-array resource. */
+  NeedsUpdate() {
+    return this.#updateScheduled || this.#dirtyLayers.size > 0 || this.#preparedRevision < this.#requestedRevision;
+  }
 
-    /**
-     * Returns revisions currently being prepared by the update handler for the
-     * texture-array resource.
-     */
-    GetInFlightRevisions(out = []) {
-      for (const revision of this.#inFlightRequests.keys()) out.push(revision);
-      return out.sort((a, b) => a - b);
-    }
+  /** Returns dirty layers from the current texture-array resource. */
+  GetDirtyLayers() {
+    return new Set(this.#dirtyLayers);
+  }
 
-    /**
-     * Reports whether a requested revision is currently being prepared for the
-     * texture-array resource.
-     */
-    IsRevisionInFlight(revision) {
-      return this.#inFlightRequests.has(revision);
-    }
+  /**
+   * Returns revisions currently being prepared by the update handler for the
+   * texture-array resource.
+   */
+  GetInFlightRevisions(out = []) {
+    for (const revision of this.#inFlightRequests.keys()) out.push(revision);
+    return out.sort((a, b) => a - b);
+  }
 
-    /** Updates update scheduler in the current texture-array resource. */
-    SetUpdateScheduler(schedule = null) {
-      if (schedule !== null && typeof schedule !== "function") {
-        throw new TypeError("CjsTextureArrayRes update scheduler must be a function or null.");
-      }
-      this.#updateScheduler = schedule;
-      if (schedule && this.#updateScheduled) schedule(this);
-      return this;
-    }
+  /**
+   * Reports whether a requested revision is currently being prepared for the
+   * texture-array resource.
+   */
+  IsRevisionInFlight(revision) {
+    return this.#inFlightRequests.has(revision);
+  }
 
-    /** Updates update handler in the current texture-array resource. */
-    SetUpdateHandler(handler = null) {
-      if (handler !== null && typeof handler !== "function") {
-        throw new TypeError("CjsTextureArrayRes update handler must be a function or null.");
-      }
-      this.#updateHandler = handler;
-      return this;
+  /** Updates update scheduler in the current texture-array resource. */
+  SetUpdateScheduler(schedule = null) {
+    if (schedule !== null && typeof schedule !== "function") {
+      throw new TypeError("CjsTextureArrayRes update scheduler must be a function or null.");
     }
+    this.#updateScheduler = schedule;
+    if (schedule && this.#updateScheduled) schedule(this);
+    return this;
+  }
 
-    /**
-     * Consume all proxy changes as one immutable request snapshot.
-     * A frame scheduler should call this at most once per parent per frame.
-     */
-    ConsumeUpdateRequest() {
-      if (!this.#updateScheduled && this.#dirtyLayers.size === 0) return null;
-      const request = Object.freeze({
-        revision: this.#requestedRevision,
-        paths: Object.freeze(this.GetLayerResourcePaths()),
-        resources: Object.freeze(this.#layers.map(layer => layer.resource)),
-        dirtyLayers: Object.freeze([...this.#dirtyLayers].sort((a, b) => a - b)),
-        topologyChanged: this.#topologyChanged
-      });
-      this.#dirtyLayers.clear();
-      this.#topologyChanged = false;
-      this.#updateScheduled = false;
-      this.#inFlightRequests.set(request.revision, request);
-      return request;
+  /** Updates update handler in the current texture-array resource. */
+  SetUpdateHandler(handler = null) {
+    if (handler !== null && typeof handler !== "function") {
+      throw new TypeError("CjsTextureArrayRes update handler must be a function or null.");
     }
+    this.#updateHandler = handler;
+    return this;
+  }
 
-    /** Requeue a consumed current request after cancellation, loss, or retryable failure. */
-    RetryUpdateRequest(revision = this.#requestedRevision) {
-      const request = this.#inFlightRequests.get(revision);
-      if (!request) return false;
-      this.#inFlightRequests.delete(revision);
-      if (revision !== this.#requestedRevision) return false;
-      if (this.#failedRevision === revision) {
-        this.#failedRevision = 0;
-        this.#failedError = null;
-      }
-      for (const layer of request.dirtyLayers) {
-        if (layer < this.#layers.length) this.#dirtyLayers.add(layer);
-      }
-      this.#topologyChanged ||= request.topologyChanged;
-      this.#ScheduleUpdate();
-      this.EmitEvent("revisionretry", this, revision);
-      return true;
-    }
+  /**
+   * Consume all proxy changes as one immutable request snapshot.
+   * A frame scheduler should call this at most once per parent per frame.
+   */
+  ConsumeUpdateRequest() {
+    if (!this.#updateScheduled && this.#dirtyLayers.size === 0) return null;
+    const request = Object.freeze({
+      revision: this.#requestedRevision,
+      paths: Object.freeze(this.GetLayerResourcePaths()),
+      resources: Object.freeze(this.#layers.map(layer => layer.resource)),
+      dirtyLayers: Object.freeze([...this.#dirtyLayers].sort((a, b) => a - b)),
+      topologyChanged: this.#topologyChanged
+    });
+    this.#dirtyLayers.clear();
+    this.#topologyChanged = false;
+    this.#updateScheduled = false;
+    this.#inFlightRequests.set(request.revision, request);
+    return request;
+  }
 
-    /** Complete a consumed request as failed, optionally making it retryable. */
-    FailUpdateRequest(revision, error, options = {}) {
-      if (options.retry) return this.RetryUpdateRequest(revision);
-      if (!this.#inFlightRequests.has(revision)) return false;
-      this.#inFlightRequests.delete(revision);
-      if (revision !== this.#requestedRevision) return false;
-      const failure = error instanceof Error ? error : new Error(String(error ?? "Texture array preparation failed."));
-      this.#failedRevision = revision;
-      this.#failedError = failure;
-      if (this.#preparedRevision === 0) this.SetError(failure);
-      this.EmitEvent("revisionfailed", this, revision, failure);
-      this.#RejectReadyWaiters(revision, failure);
-      return true;
+  /** Requeue a consumed current request after cancellation, loss, or retryable failure. */
+  RetryUpdateRequest(revision = this.#requestedRevision) {
+    const request = this.#inFlightRequests.get(revision);
+    if (!request) return false;
+    this.#inFlightRequests.delete(revision);
+    if (revision !== this.#requestedRevision) return false;
+    if (this.#failedRevision === revision) {
+      this.#failedRevision = 0;
+      this.#failedError = null;
     }
-
-    /** Run the registered update handler for the current coalesced frame request. */
-    Update(context = {}) {
-      const request = this.ConsumeUpdateRequest();
-      if (!request) return null;
-      this.EmitEvent("update", this, request, context);
-      return this.#updateHandler ? this.#updateHandler(this, request, context) : request;
+    for (const layer of request.dirtyLayers) {
+      if (layer < this.#layers.length) this.#dirtyLayers.add(layer);
     }
+    this.#topologyChanged ||= request.topologyChanged;
+    this.#ScheduleUpdate();
+    this.EmitEvent("revisionretry", this, revision);
+    return true;
+  }
 
-    /**
-     * Atomically publish an opaque adapter allocation with its prepared revision.
-     * The caller owns disposal of a successfully displaced allocation.
-     */
-    CommitPreparedAdapterRevision(revision, adapterKey, candidate, options = {}) {
-      if (!adapterKey) throw new TypeError("CjsTextureArrayRes adapter publication requires a key.");
-      if (candidate === null || candidate === undefined) {
-        throw new TypeError("CjsTextureArrayRes adapter publication requires a candidate allocation.");
-      }
-      const inFlight = this.#inFlightRequests.has(revision);
-      if (!inFlight || revision !== this.#requestedRevision) {
-        if (inFlight) this.#inFlightRequests.delete(revision);
-        if (options.destroyRejected !== false) destroyAdapterValue(candidate);
-        return Object.freeze({
-          published: false,
-          revision,
-          displaced: null
-        });
-      }
-      const displaced = this.GetAdapterResource(adapterKey);
-      this.SetAdapterResource(adapterKey, candidate);
-      this.#preparedRevision = revision;
-      this.#failedRevision = 0;
-      this.#failedError = null;
-      this.#inFlightRequests.delete(revision);
-      for (const pendingRevision of this.#inFlightRequests.keys()) {
-        if (pendingRevision < revision) this.#inFlightRequests.delete(pendingRevision);
-      }
-      this.MarkPrepared();
-      this.EmitEvent("revisionprepared", this, revision, adapterKey, candidate);
-      this.#ResolveReadyWaiters(revision);
+  /** Complete a consumed request as failed, optionally making it retryable. */
+  FailUpdateRequest(revision, error, options = {}) {
+    if (options.retry) return this.RetryUpdateRequest(revision);
+    if (!this.#inFlightRequests.has(revision)) return false;
+    this.#inFlightRequests.delete(revision);
+    if (revision !== this.#requestedRevision) return false;
+    const failure = error instanceof Error ? error : new Error(String(error ?? "Texture array preparation failed."));
+    this.#failedRevision = revision;
+    this.#failedError = failure;
+    if (this.#preparedRevision === 0) this.SetError(failure);
+    this.EmitEvent("revisionfailed", this, revision, failure);
+    this.#RejectReadyWaiters(revision, failure);
+    return true;
+  }
+
+  /** Run the registered update handler for the current coalesced frame request. */
+  Update(context = {}) {
+    const request = this.ConsumeUpdateRequest();
+    if (!request) return null;
+    this.EmitEvent("update", this, request, context);
+    return this.#updateHandler ? this.#updateHandler(this, request, context) : request;
+  }
+
+  /**
+   * Atomically publish an opaque adapter allocation with its prepared revision.
+   * The caller owns disposal of a successfully displaced allocation.
+   */
+  CommitPreparedAdapterRevision(revision, adapterKey, candidate, options = {}) {
+    if (!adapterKey) throw new TypeError("CjsTextureArrayRes adapter publication requires a key.");
+    if (candidate === null || candidate === undefined) {
+      throw new TypeError("CjsTextureArrayRes adapter publication requires a candidate allocation.");
+    }
+    const inFlight = this.#inFlightRequests.has(revision);
+    if (!inFlight || revision !== this.#requestedRevision) {
+      if (inFlight) this.#inFlightRequests.delete(revision);
+      if (options.destroyRejected !== false) destroyAdapterValue(candidate);
       return Object.freeze({
-        published: true,
+        published: false,
         revision,
-        displaced: displaced === candidate ? null : displaced
+        displaced: null
       });
     }
+    const displaced = this.GetAdapterResource(adapterKey);
+    this.SetAdapterResource(adapterKey, candidate);
+    this.#preparedRevision = revision;
+    this.#failedRevision = 0;
+    this.#failedError = null;
+    this.#inFlightRequests.delete(revision);
+    for (const pendingRevision of this.#inFlightRequests.keys()) {
+      if (pendingRevision < revision) this.#inFlightRequests.delete(pendingRevision);
+    }
+    this.MarkPrepared();
+    this.EmitEvent("revisionprepared", this, revision, adapterKey, candidate);
+    this.#ResolveReadyWaiters(revision);
+    return Object.freeze({
+      published: true,
+      revision,
+      displaced: displaced === candidate ? null : displaced
+    });
+  }
 
-    /** Destroy an unusable adapter allocation and request a complete rebuild. */
-    HandleAdapterLoss(adapterKey, options = {}) {
-      if (!adapterKey) throw new TypeError("CjsTextureArrayRes adapter loss requires a key.");
-      const lost = this.GetAdapterResource(adapterKey);
-      if (this.HasAdapterResource(adapterKey)) this.DestroyAdapterResource(adapterKey, options);
-      this.#preparedRevision = 0;
-      if (this.#layers.length) this.#InvalidateRange(this.#layers.length, true);
-      if (this.state === _CjsResource.State.PREPARED) this.MarkPreparing();
-      this.EmitEvent("adapterlost", this, adapterKey, lost);
-      return lost;
-    }
+  /** Destroy an unusable adapter allocation and request a complete rebuild. */
+  HandleAdapterLoss(adapterKey, options = {}) {
+    if (!adapterKey) throw new TypeError("CjsTextureArrayRes adapter loss requires a key.");
+    const lost = this.GetAdapterResource(adapterKey);
+    if (this.HasAdapterResource(adapterKey)) this.DestroyAdapterResource(adapterKey, options);
+    this.#preparedRevision = 0;
+    if (this.#layers.length) this.#InvalidateRange(this.#layers.length, true);
+    if (this.state === CjsResource.State.PREPARED) this.MarkPreparing();
+    this.EmitEvent("adapterlost", this, adapterKey, lost);
+    return lost;
+  }
 
-    /** Resolve when the generation requested at call time has been prepared. */
-    Ready() {
-      if (this.#requestedRevision === 0) {
-        const error = new Error("Texture array resource has no configured layers.");
-        error.code = "CJS_TEXTURE_ARRAY_UNCONFIGURED";
-        return Promise.reject(error);
-      }
-      const revision = this.#requestedRevision;
-      if (this.#preparedRevision >= revision && this.IsPrepared()) return Promise.resolve(this);
-      if (this.#failedRevision === revision) return Promise.reject(this.#failedError);
-      return new Promise((resolve, reject) => {
-        this.#readyWaiters.push({
-          revision,
-          resolve,
-          reject
-        });
+  /** Resolve when the generation requested at call time has been prepared. */
+  Ready() {
+    if (this.#requestedRevision === 0) {
+      const error = new Error("Texture array resource has no configured layers.");
+      error.code = "CJS_TEXTURE_ARRAY_UNCONFIGURED";
+      return Promise.reject(error);
+    }
+    const revision = this.#requestedRevision;
+    if (this.#preparedRevision >= revision && this.IsPrepared()) return Promise.resolve(this);
+    if (this.#failedRevision === revision) return Promise.reject(this.#failedError);
+    return new Promise((resolve, reject) => {
+      this.#readyWaiters.push({
+        revision,
+        resolve,
+        reject
       });
-    }
+    });
+  }
 
-    /** Creates one texture-array layer record for the texture-array resource. */
-    #CreateLayer(layer, name = "", path = "") {
-      return {
-        path: normalizeResourcePath(path),
-        resource: null,
-        proxy: new CjsTextureArrayResParameterProxy(this, layer, {
-          name
-        })
-      };
-    }
+  /** Creates one texture-array layer record for the texture-array resource. */
+  #CreateLayer(layer, name = "", path = "") {
+    return {
+      path: normalizeResourcePath(path),
+      resource: null,
+      proxy: new CjsTextureArrayResParameterProxy(this, layer, {
+        name
+      })
+    };
+  }
 
-    /**
-     * Returns a validated texture-array layer record for the texture-array
-     * resource.
-     */
-    #GetLayer(layer) {
-      if (!Number.isInteger(layer) || layer < 0 || layer >= this.#layers.length) {
-        throw new RangeError(`CjsTextureArrayRes layer ${layer} is out of range.`);
-      }
-      return this.#layers[layer];
+  /**
+   * Returns a validated texture-array layer record for the texture-array
+   * resource.
+   */
+  #GetLayer(layer) {
+    if (!Number.isInteger(layer) || layer < 0 || layer >= this.#layers.length) {
+      throw new RangeError(`CjsTextureArrayRes layer ${layer} is out of range.`);
     }
+    return this.#layers[layer];
+  }
 
-    /** Updates layer names in the current texture-array resource. */
-    #SetLayerNames(names) {
-      if (!names) return;
-      for (let layer = 0; layer < Math.min(names.length, this.#layers.length); layer++) {
-        this.#layers[layer].proxy.SetParameterName(names[layer]);
-      }
+  /** Updates layer names in the current texture-array resource. */
+  #SetLayerNames(names) {
+    if (!names) return;
+    for (let layer = 0; layer < Math.min(names.length, this.#layers.length); layer++) {
+      this.#layers[layer].proxy.SetParameterName(names[layer]);
     }
+  }
 
-    /** Invalidates one texture-array layer for the texture-array resource. */
-    #InvalidateLayer(layer) {
-      this.#InvalidateLayers([layer]);
-    }
+  /** Invalidates one texture-array layer for the texture-array resource. */
+  #InvalidateLayer(layer) {
+    this.#InvalidateLayers([layer]);
+  }
 
-    /**
-     * Invalidates the requested texture-array layer range for the texture-array
-     * resource.
-     */
-    #InvalidateRange(count, topologyChanged = false) {
-      const layers = [];
-      for (let layer = 0; layer < count; layer++) layers.push(layer);
-      this.#InvalidateLayers(layers, topologyChanged);
-    }
+  /**
+   * Invalidates the requested texture-array layer range for the texture-array
+   * resource.
+   */
+  #InvalidateRange(count, topologyChanged = false) {
+    const layers = [];
+    for (let layer = 0; layer < count; layer++) layers.push(layer);
+    this.#InvalidateLayers(layers, topologyChanged);
+  }
 
-    /**
-     * Invalidates the supplied texture-array layers for the texture-array
-     * resource.
-     */
-    #InvalidateLayers(layers, topologyChanged = false) {
-      const changed = [];
-      for (const layer of layers) {
-        if (!Number.isInteger(layer) || layer < 0 || layer >= this.#layers.length) continue;
-        this.#dirtyLayers.add(layer);
-        changed.push(layer);
-      }
-      if (!changed.length && !topologyChanged) return;
-      this.#topologyChanged ||= topologyChanged;
-      this.#failedRevision = 0;
-      this.#failedError = null;
-      this.#requestedRevision += 1;
-      this.#ScheduleUpdate();
-      this.EmitEvent("invalidated", this, Object.freeze(changed), this.#requestedRevision, Object.freeze({
-        topologyChanged: this.#topologyChanged
-      }));
-    }
+  /**
+   * Invalidates the supplied texture-array layers for the texture-array
+   * resource.
+   */
+  #InvalidateLayers(layers, topologyChanged = false) {
+    const changed = [];
+    for (const layer of layers) {
+      if (!Number.isInteger(layer) || layer < 0 || layer >= this.#layers.length) continue;
+      this.#dirtyLayers.add(layer);
+      changed.push(layer);
+    }
+    if (!changed.length && !topologyChanged) return;
+    this.#topologyChanged ||= topologyChanged;
+    this.#failedRevision = 0;
+    this.#failedError = null;
+    this.#requestedRevision += 1;
+    this.#ScheduleUpdate();
+    this.EmitEvent("invalidated", this, Object.freeze(changed), this.#requestedRevision, Object.freeze({
+      topologyChanged: this.#topologyChanged
+    }));
+  }
 
-    /** Schedules the coalesced texture-array update for the texture-array resource. */
-    #ScheduleUpdate() {
-      if (this.#updateScheduled) return;
-      this.#updateScheduled = true;
-      this.#updateScheduler?.(this);
-    }
+  /** Schedules the coalesced texture-array update for the texture-array resource. */
+  #ScheduleUpdate() {
+    if (this.#updateScheduled) return;
+    this.#updateScheduled = true;
+    this.#updateScheduler?.(this);
+  }
 
-    /**
-     * Resolves waiters satisfied by the prepared revision for the texture-array
-     * resource.
-     */
-    #ResolveReadyWaiters(revision) {
-      const pending = [];
-      for (const waiter of this.#readyWaiters) {
-        if (waiter.revision <= revision) waiter.resolve(this);else pending.push(waiter);
-      }
-      this.#readyWaiters = pending;
+  /**
+   * Resolves waiters satisfied by the prepared revision for the texture-array
+   * resource.
+   */
+  #ResolveReadyWaiters(revision) {
+    const pending = [];
+    for (const waiter of this.#readyWaiters) {
+      if (waiter.revision <= revision) waiter.resolve(this);else pending.push(waiter);
     }
+    this.#readyWaiters = pending;
+  }
 
-    /**
-     * Rejects waiters affected by a failed revision for the texture-array
-     * resource.
-     */
-    #RejectReadyWaiters(revision, error) {
-      const pending = [];
-      for (const waiter of this.#readyWaiters) {
-        if (waiter.revision <= revision) waiter.reject(error);else pending.push(waiter);
-      }
-      this.#readyWaiters = pending;
+  /**
+   * Rejects waiters affected by a failed revision for the texture-array
+   * resource.
+   */
+  #RejectReadyWaiters(revision, error) {
+    const pending = [];
+    for (const waiter of this.#readyWaiters) {
+      if (waiter.revision <= revision) waiter.reject(error);else pending.push(waiter);
     }
-  }];
-  payload = "texture-array";
-  constructor() {
-    super(_CjsTextureArrayRes), _initClass();
+    this.#readyWaiters = pending;
   }
-}();
+  static payload = "texture-array";
+}
 function destroyAdapterValue(value) {
   if (!value || typeof value !== "object" && typeof value !== "function") return;
   const destroy = value.Destroy || value.Dispose || value.destroy || value.dispose;
   if (typeof destroy === "function") destroy.call(value);
 }
+CjsSchema.define(CjsTextureArrayRes, {
+  className: "CjsTextureArrayRes",
+  family: "resource"
+});
 
-export { _CjsTextureArrayRes as CjsTextureArrayRes };
+export { CjsTextureArrayRes };
 //# sourceMappingURL=CjsTextureArrayRes.js.map