@wildshard/shard-format 0.0.1 → 0.4.6

package/src/format/forestWeather.ts

@@ -0,0 +1,333 @@
+/** Data-only client weather bindings; safe for schema discovery in Node. */
+import * as v from 'valibot';
+import { WeatherWorldSchema, WeatherShelterCirclesSchema } from './weatherProgram.ts';
+
+const n = v.pipe(v.number(), v.finite()), id = v.pipe(v.string(), v.minLength(1));
+const count = v.pipe(n, v.integer(), v.minValue(1), v.maxValue(16384));
+const tiered = v.strictObject({ phone: n, desktop: n });
+/** One drawn part of the weather: a lent look on a baked shape (a mesh, points, or an instanced shape placed by a matrix
+ *  table of the parts file), or a sprite of a parts texture. Hidden until the lane's `flags.<id>` is above 0. */
+const PartSchema = v.variant('kind', [
+  v.strictObject({ kind: v.picklist(['mesh', 'points']), id, shape: id, look: id, order: n }),
+  v.strictObject({ kind: v.literal('instanced'), id, shape: id, look: id, order: n, matrices: id }),
+  v.strictObject({ kind: v.literal('sprite'), id, texture: id, order: n, fog: v.boolean(), toneMapped: v.boolean() }),
+]);
+/** A square RGBA texture from a byte table of the parts file, lent to `[look, uniform]` pairs. */
+const TextureSchema = v.strictObject({ id, bytes: id, size: count, noise: v.boolean(), lend: v.pipe(v.array(v.tuple([id, id])), v.maxLength(16)) });
+/** The weather's drawn parts and the channel lane that poses them (`lane`; `params` the looks whose params it writes). */
+const PartsSchema = v.strictObject({
+  file: id, lane: id, params: v.pipe(v.array(id), v.maxLength(32)),
+  textures: v.pipe(v.array(TextureSchema), v.maxLength(8)), parts: v.pipe(v.array(PartSchema), v.maxLength(16)),
+  /** a camera-local streak curtain in `look` (offset, velocity, colour, length and alpha from the lane's `rainU`) */
+  rain: v.exactOptional(v.strictObject({ look: id, radius: tiered, streaks: tiered, order: n })),
+});
+/** A voice played on a reaction event: `near` at the event's x z (gain falling to `floor` at `range` m, none beyond),
+ *  `distant` at the event's `distance` along its `bearing`, `reach` m out. */
+const CueSchema = v.strictObject({ event: id, patch: id, kind: v.picklist(['near', 'distant']), range: n, floor: n, reach: n });
+/** Weather reactions on the page: the bundle file (`weather` + `reactions`), struck at the world forest's crowns, sheltered
+ *  by the original shelter circles and hurting through the complete weather-world rows; held while the page answers `weather.indoors` / `weather.storm-hold`. */
+const StormSchema = v.strictObject({
+  /** `idle` the calm phase: no storm wind bed, and the parts lane's `active` is 0 */
+  file: id, idle: id, world: WeatherWorldSchema, shelters: WeatherShelterCirclesSchema, cues: v.pipe(v.array(CueSchema), v.maxLength(8)),
+  /** the group's `rain` and `wind` (the steppe wind's smoothstep over `range` m/s, silent while idle) every `every` s */
+  beds: v.strictObject({ group: id, every: n, rain: id, wind: id, range: v.tuple([n, n]) }),
+});
+const phase = v.picklist(['dawn', 'day', 'golden', 'dusk', 'night']);
+/** An hour clock's row (`@wildshard/shard-format/dayCycle` DayClockRow). */
+const HourClockSchema = v.strictObject({ units: v.literal('hour'), start: n, sun: v.strictObject({ maxElevation: n, azimuthOffset: n }),
+  schedule: v.pipe(v.array(v.strictObject({ phase, from: n, to: n, minutes: n })), v.minLength(1), v.maxLength(16)), pauseOnPin: v.boolean(),
+  fixed: v.strictObject({ midday: n, golden: n, sunset: n, night: n }), presets: v.strictObject({ dawn: n, noon: n, dusk: n, night: n }) });
+/**
+ * A painted sky (the keyed-sky host's second kind, game/looks/keyedSky `paintedSky`): an hour clock; the file's day key
+ * (`sky.day`, its `from` fields started from the scene's fog colour, the painterly shade and rim and `light` its key
+ * intensity) keyed by the `key` lane and sampled by the `sample` lane into a look of the file's day-look schema; the dome
+ * (a file shape in a lent look); the `weather` lane laying the weather over the look, the `dome` lane (flash × `flash`) and
+ * the `tint` lane (the panorama's re-grade and the `tint` looks' params). The look is the parts lane's `look` owner.
+ */
+const PaintedSkySchema: v.GenericSchema<PaintedSkyRowsInput, PaintedSkyRows> = v.strictObject({
+  file: id, clock: HourClockSchema, dome: v.strictObject({ shape: id, look: id, order: n }), flash: n,
+  lanes: v.strictObject({ key: id, sample: id, dome: id, weather: id, tint: id }), tint: v.pipe(v.array(id), v.maxLength(8)),
+  from: v.strictObject({ fog: id, shade: id, rim: id, light: id }),
+  moon: v.strictObject({ disc: v.tuple([n, n, n]), gain: n, scale: n, halo: n, haloOpacity: n }),
+});
+
+/** Native presentation bindings are resource ids and numeric policies only. A page runs a phase `program` on its own
+ *  system, or a `storm` its reactions step; the forest blocks (observations, rain, shelter, focus, the `channels` lane) are
+ *  each optional. */
+export const ForestWeatherSchema: v.GenericSchema<ForestWeatherRowsInput, ForestWeatherRows> = v.pipe(v.strictObject({
+  files: v.strictObject({ observations: v.exactOptional(id), rain: v.exactOptional(id), program: v.exactOptional(id), shelter: v.exactOptional(id) }),
+  mode: v.picklist(['setting', 'live']), channels: v.exactOptional(id), debug: id, heldPhase: n,
+  focus: v.exactOptional(v.strictObject({ kind: id, variant: id, near: n, threshold: n, retention: n, height: n, radius: n, gain: n })),
+  sky: v.exactOptional(PaintedSkySchema), storm: v.exactOptional(StormSchema), parts: v.exactOptional(PartsSchema),
+  system: v.strictObject({ id, after: v.array(id), before: v.array(id) }),
+}), v.check(row => (row.files.program === undefined) !== (row.storm === undefined), 'one weather owner: a program or a storm'),
+  v.check(row => (row.files.observations === undefined) === (row.files.rain === undefined && row.files.shelter === undefined && row.focus === undefined && row.channels === undefined),
+    'the forest blocks come together'));
+
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+export type PaintedSkyRowsInput = PaintedSkyRows;
+interface PaintedSkyRowsFields {
+    file: string;
+    clock: {
+        units: 'hour';
+        start: number;
+        sun: {
+            maxElevation: number;
+            azimuthOffset: number;
+        };
+        schedule: ({
+            phase: 'dawn' | 'day' | 'golden' | 'dusk' | 'night';
+            from: number;
+            to: number;
+            minutes: number;
+        })[];
+        pauseOnPin: boolean;
+        fixed: {
+            midday: number;
+            golden: number;
+            sunset: number;
+            night: number;
+        };
+        presets: {
+            dawn: number;
+            noon: number;
+            dusk: number;
+            night: number;
+        };
+    };
+    dome: {
+        shape: string;
+        look: string;
+        order: number;
+    };
+    flash: number;
+    lanes: {
+        key: string;
+        sample: string;
+        dome: string;
+        weather: string;
+        tint: string;
+    };
+    tint: (string)[];
+    from: {
+        fog: string;
+        shade: string;
+        rim: string;
+        light: string;
+    };
+    moon: {
+        disc: [
+            number,
+            number,
+            number
+        ];
+        gain: number;
+        scale: number;
+        halo: number;
+        haloOpacity: number;
+    };
+}
+export type PaintedSkyRows = { [Key in keyof PaintedSkyRowsFields]: PaintedSkyRowsFields[Key] };
+interface ForestWeatherRowsInputFields {
+    files: {
+        observations?: string;
+        rain?: string;
+        program?: string;
+        shelter?: string;
+    };
+    mode: 'setting' | 'live';
+    channels?: string;
+    debug: string;
+    heldPhase: number;
+    focus?: {
+        kind: string;
+        variant: string;
+        near: number;
+        threshold: number;
+        retention: number;
+        height: number;
+        radius: number;
+        gain: number;
+    };
+    sky?: PaintedSkyRowsInput;
+    storm?: {
+        file: string;
+        idle: string;
+        world: v.InferOutput<typeof WeatherWorldSchema>;
+        shelters: v.InferOutput<typeof WeatherShelterCirclesSchema>;
+        cues: ({
+            event: string;
+            patch: string;
+            kind: 'near' | 'distant';
+            range: number;
+            floor: number;
+            reach: number;
+        })[];
+        beds: {
+            group: string;
+            every: number;
+            rain: string;
+            wind: string;
+            range: [
+                number,
+                number
+            ];
+        };
+    };
+    parts?: {
+        file: string;
+        lane: string;
+        params: (string)[];
+        textures: ({
+            id: string;
+            bytes: string;
+            size: number;
+            noise: boolean;
+            lend: ([
+                string,
+                string
+            ])[];
+        })[];
+        parts: (({
+            kind: 'mesh' | 'points';
+            id: string;
+            shape: string;
+            look: string;
+            order: number;
+        }) | ({
+            kind: 'instanced';
+            id: string;
+            shape: string;
+            look: string;
+            order: number;
+            matrices: string;
+        }) | ({
+            kind: 'sprite';
+            id: string;
+            texture: string;
+            order: number;
+            fog: boolean;
+            toneMapped: boolean;
+        }))[];
+        rain?: {
+            look: string;
+            radius: {
+                phone: number;
+                desktop: number;
+            };
+            streaks: {
+                phone: number;
+                desktop: number;
+            };
+            order: number;
+        };
+    };
+    system: {
+        id: string;
+        after: (string)[];
+        before: (string)[];
+    };
+}
+export type ForestWeatherRowsInput = { [Key in keyof ForestWeatherRowsInputFields]: ForestWeatherRowsInputFields[Key] };
+interface ForestWeatherRowsFields {
+    files: {
+        observations?: string;
+        rain?: string;
+        program?: string;
+        shelter?: string;
+    };
+    mode: 'setting' | 'live';
+    channels?: string;
+    debug: string;
+    heldPhase: number;
+    focus?: {
+        kind: string;
+        variant: string;
+        near: number;
+        threshold: number;
+        retention: number;
+        height: number;
+        radius: number;
+        gain: number;
+    };
+    sky?: PaintedSkyRows;
+    storm?: {
+        file: string;
+        idle: string;
+        world: v.InferOutput<typeof WeatherWorldSchema>;
+        shelters: v.InferOutput<typeof WeatherShelterCirclesSchema>;
+        cues: ({
+            event: string;
+            patch: string;
+            kind: 'near' | 'distant';
+            range: number;
+            floor: number;
+            reach: number;
+        })[];
+        beds: {
+            group: string;
+            every: number;
+            rain: string;
+            wind: string;
+            range: [
+                number,
+                number
+            ];
+        };
+    };
+    parts?: {
+        file: string;
+        lane: string;
+        params: (string)[];
+        textures: ({
+            id: string;
+            bytes: string;
+            size: number;
+            noise: boolean;
+            lend: ([
+                string,
+                string
+            ])[];
+        })[];
+        parts: (({
+            kind: 'mesh' | 'points';
+            id: string;
+            shape: string;
+            look: string;
+            order: number;
+        }) | ({
+            kind: 'instanced';
+            id: string;
+            shape: string;
+            look: string;
+            order: number;
+            matrices: string;
+        }) | ({
+            kind: 'sprite';
+            id: string;
+            texture: string;
+            order: number;
+            fog: boolean;
+            toneMapped: boolean;
+        }))[];
+        rain?: {
+            look: string;
+            radius: {
+                phone: number;
+                desktop: number;
+            };
+            streaks: {
+                phone: number;
+                desktop: number;
+            };
+            order: number;
+        };
+    };
+    system: {
+        id: string;
+        after: (string)[];
+        before: (string)[];
+    };
+}
+export type ForestWeatherRows = { [Key in keyof ForestWeatherRowsFields]: ForestWeatherRowsFields[Key] };

package/src/format/geometryPack.ts

@@ -0,0 +1,136 @@
+import * as v from 'valibot';
+
+const text = v.pipe(v.string(), v.minLength(1), v.maxLength(512));
+const natural = v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(100_000_000));
+/** Existing packed-geometry codec metadata, shared by collection displays and held finish extras. */
+export const PackedGeometryRowsSchema: v.GenericSchema<PackedGeometryRowsRowsInput, PackedGeometryRowsRows> = v.strictObject({ bytes: natural,
+  geometries: v.pipe(v.array(v.strictObject({
+    attrs: v.pipe(v.array(v.tuple([text, natural])), v.maxLength(32)), count: natural, unique: natural,
+    own: v.nullable(v.picklist(['u16', 'u32'])), indexCount: natural,
+    groups: v.exactOptional(v.pipe(v.array(v.strictObject({ start: natural, count: natural, materialIndex: natural })), v.maxLength(128))),
+  })), v.maxLength(128)),
+});
+
+/**
+ * A pack of float32 geometries as an offline bake stores them (the packed geometry format): each geometry's unique
+ * vertices as one block per attribute, then its index (16 or 32 bit, 4-byte aligned), described by a row each. A geometry
+ * the builder left indexed (`own`) comes back with its own copies of the blocks and its index; one the builder left
+ * non-indexed (`own: null`) is expanded back through the index to `count` vertices, exactly as the builder had it.
+ */
+
+/** One draw group of a packed geometry: its index range and material slot, as three keeps it. */
+export interface PackedGroup { readonly start: number; readonly count: number; readonly materialIndex: number }
+
+/** One packed geometry: its attributes [name, item size], its vertex count, its unique vertices, its index. */
+export interface PackedGeometryRow {
+  readonly attrs: readonly (readonly [string, number])[];
+  readonly count: number;
+  readonly unique: number;
+  /** the index the builder kept ('u16' / 'u32'), or null: expand it away */
+  readonly own: 'u16' | 'u32' | null;
+  readonly indexCount: number;
+  /** the builder's draw groups (a primitive's side and caps, say), when it had any */
+  readonly groups?: readonly PackedGroup[];
+}
+
+/** A pack's rows: its byte size and its geometries in byte order. */
+export interface PackedGeometryRows {
+  readonly bytes: number;
+  readonly geometries: readonly PackedGeometryRow[];
+}
+
+/** A pack's rows as JSON holds them (each attribute pair an array, the index kind a string). */
+export interface PackedGeometryJson {
+  readonly bytes: number;
+  readonly geometries: readonly { readonly attrs: readonly (readonly (string | number)[])[]; readonly count: number; readonly unique: number; readonly own: string | null; readonly indexCount: number; readonly groups?: readonly PackedGroup[] }[];
+}
+
+/** JSON rows checked into a pack's rows: every attribute pair is [name, item size], every index 'u16', 'u32' or null. */
+export function packedRows(json: PackedGeometryJson): PackedGeometryRows {
+  return { bytes: json.bytes, geometries: json.geometries.map((g) => {
+    const attrs = g.attrs.map(([name, size]) => {
+      if (typeof name !== 'string' || typeof size !== 'number') throw new Error('geometry pack: an attribute row is [name, size]');
+      return [name, size] as const;
+    });
+    if (g.own !== null && g.own !== 'u16' && g.own !== 'u32') throw new Error(`geometry pack: index kind ${g.own}`);
+    return { attrs, count: g.count, unique: g.unique, own: g.own, indexCount: g.indexCount, ...(g.groups === undefined ? {} : { groups: g.groups }) };
+  }) };
+}
+
+/** Independent CPU storage for one decoded geometry. */
+export interface PackedGeometryData {
+  readonly attributes: readonly { readonly name: string; readonly size: number; readonly array: Float32Array }[];
+  readonly index: Uint16Array | Uint32Array | null;
+  readonly groups: readonly PackedGroup[];
+}
+
+/** The decoded binary: each geometry's blocks, read fresh for every geometry built from it (nothing is shared). */
+export class GeometryPackData {
+  private readonly at: number[] = [];
+  private readonly buffer: ArrayBuffer;
+  private readonly rows: PackedGeometryRows;
+  private readonly label: string;
+
+  /** `bytes` the inflated binary, `rows` its description, `label` the error messages' name. */
+  constructor(bytes: Uint8Array, rows: PackedGeometryRows, label: string) {
+    this.rows = rows; this.label = label;
+    if (bytes.length !== rows.bytes) throw new Error(`[${label}] the bake holds ${String(bytes.length)} bytes, its rows ${String(rows.bytes)}`);
+    this.buffer = new ArrayBuffer(bytes.length); new Uint8Array(this.buffer).set(bytes);
+    let offset = 0;
+    const pad = (n: number): number => Math.ceil(n / 4) * 4;
+    for (const g of rows.geometries) {
+      this.at.push(offset);
+      for (const [, size] of g.attrs) offset += pad(g.unique * size * 4);
+      offset += pad(g.indexCount * (g.own === 'u32' || (g.own === null && g.unique >= 65536) ? 4 : 2));
+    }
+    if (offset !== bytes.length) throw new Error(`[${label}] the bake does not match its rows`);
+  }
+
+  /** Decode independent mutable arrays without constructing renderer objects. */
+  read(i: number): PackedGeometryData {
+    const row = this.rows.geometries[i], start = this.at[i];
+    if (row === undefined || start === undefined) throw new Error(`[${this.label}] no baked geometry ${String(i)}`);
+    let offset = start;
+    const blocks = row.attrs.map(([, size]) => { const a = new Float32Array(this.buffer, offset, row.unique * size); offset += Math.ceil(a.byteLength / 4) * 4; return a; });
+    const wide = row.own === 'u32' || (row.own === null && row.unique >= 65536);
+    const index = wide ? new Uint32Array(this.buffer, offset, row.indexCount) : new Uint16Array(this.buffer, offset, row.indexCount);
+    const attributes: { name: string; size: number; array: Float32Array }[] = [];
+    row.attrs.forEach(([name, size], k) => {
+      const block = blocks[k]; if (block === undefined) return;
+      if (row.own !== null) { attributes.push({ name, size, array: block.slice() }); return; }
+      const array = new Float32Array(row.count * size);
+      for (let j = 0; j < row.count; j++) { const src = (index[j] ?? 0) * size; for (let c = 0; c < size; c++) array[j * size + c] = block[src + c] ?? 0; }
+      attributes.push({ name, size, array });
+    });
+    return { attributes, index: row.own === null ? null : index.slice(), groups: (row.groups ?? []).map(({ start: groupStart, count, materialIndex }) => ({ start: groupStart, count, materialIndex })) };
+  }
+
+  /** float block `i` (`GeometryPackWriter.addFloats`): a copy of its floats, exactly as written (a `-0` stays `-0`) */
+  floats(i: number): Float32Array {
+    const attribute = this.read(i).attributes.find(row => row.name === 'values');
+    if (attribute === undefined) throw new Error(`[${this.label}] ${String(i)} is not a float block`);
+    return attribute.array;
+  }
+}
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+export type PackedGeometryRowsRowsInput = PackedGeometryRowsRows;
+interface PackedGeometryRowsRowsFields {
+    bytes: number;
+    geometries: ({
+        attrs: ([
+            string,
+            number
+        ])[];
+        count: number;
+        unique: number;
+        own: ('u16' | 'u32') | null;
+        indexCount: number;
+        groups?: ({
+            start: number;
+            count: number;
+            materialIndex: number;
+        })[];
+    })[];
+}
+export type PackedGeometryRowsRows = { [Key in keyof PackedGeometryRowsRowsFields]: PackedGeometryRowsRowsFields[Key] };

package/src/format/glbBuffers.ts

@@ -0,0 +1,77 @@
+import { MeshoptDecoder } from 'meshoptimizer/decoder';
+
+/** Await at the asynchronous asset boundary, never during module evaluation (Safari <27). */
+export function prepareGlbBuffers(): Promise<void> { return MeshoptDecoder.ready; }
+const MAX_BYTES = 25_000_000;
+const EXT = 'EXT_meshopt_compression';
+const record = (value: unknown): Record<string, unknown> => {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) throw new Error('GLB buffer object required');
+  return value as Record<string, unknown>;
+};
+const list = (value: unknown): unknown[] => {
+  if (!Array.isArray(value) || value.length > 10_000) throw new Error('GLB buffer array outside cap');
+  return value;
+};
+function count(value: unknown, maximum = MAX_BYTES): number {
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0 || value > maximum) throw new Error('GLB buffer count outside cap');
+  return value;
+}
+function extension(row: Record<string, unknown>): Record<string, unknown> | undefined {
+  const extensions = row['extensions'];
+  return extensions === undefined ? undefined : record(extensions)[EXT] === undefined ? undefined : record(record(extensions)[EXT]);
+}
+
+/** Bound physical and virtual meshopt buffers before decoding. Return ordinary contiguous views so all existing
+ * finite-position, index, skin, animation and triangle checks inspect the decoded bytes, never compressed bytes.
+ * The caller owns doc: normalization updates its buffer views in place. */
+export function glbBuffers(doc: Record<string, unknown>, physical: Uint8Array): { views: Record<string, unknown>[]; bytes: Uint8Array; decoded: number } {
+  const buffers = list(doc['buffers'] ?? []).map(record), views = list(doc['bufferViews'] ?? []).map(record);
+  const lengths = buffers.map((buffer, index) => {
+    const length = count(buffer['byteLength']);
+    if (buffer['uri'] !== undefined) throw new Error('external GLB buffer');
+    if (index === 0) {
+      if (length > physical.length || extension(buffer) !== undefined) throw new Error('truncated GLB buffer');
+    } else if (extension(buffer)?.['fallback'] !== true || !list(doc['extensionsRequired'] ?? []).includes(EXT)) throw new Error('GLB virtual buffer requires meshopt fallback');
+    return length;
+  });
+  if (lengths.reduce((sum, length) => sum + length, 0) > MAX_BYTES) throw new Error('GLB aggregate buffer cap');
+  let total = 0;
+  const rows = views.map(view => {
+    const buffer = count(view['buffer'] ?? 0, 9999), offset = count(view['byteOffset'] ?? 0), length = count(view['byteLength']);
+    const available = lengths[buffer];
+    if (available === undefined || offset + length > available) throw new Error('GLB buffer view outside buffer');
+    const codec = extension(view);
+    total += length;
+    if (total > MAX_BYTES) throw new Error('GLB decoded view cap');
+    if (codec === undefined) {
+      if (buffer !== 0) throw new Error('GLB virtual view needs meshopt data');
+      return { view, offset, length, source: physical.subarray(offset, offset + length) };
+    }
+    if (!list(doc['extensionsUsed'] ?? []).includes(EXT)) throw new Error('GLB meshopt extension is undeclared');
+    const sourceBuffer = count(codec['buffer'], 9999), sourceOffset = count(codec['byteOffset'] ?? 0), sourceLength = count(codec['byteLength']);
+    if (sourceBuffer !== 0 || sourceOffset + sourceLength > (lengths[0] ?? 0)) throw new Error('GLB meshopt source outside physical buffer');
+    const size = count(codec['byteStride'], 256), elements = count(codec['count'], 4_000_000);
+    const mode = codec['mode'], filter = codec['filter'] ?? 'NONE';
+    if (size === 0 || elements * size !== length || (view['byteStride'] !== undefined && view['byteStride'] !== size)
+      || typeof mode !== 'string' || typeof filter !== 'string'
+      || !['ATTRIBUTES', 'TRIANGLES', 'INDICES'].includes(mode)
+      || !['NONE', 'OCTAHEDRAL', 'QUATERNION', 'EXPONENTIAL'].includes(filter)) throw new Error('Invalid GLB meshopt layout');
+    if (mode === 'ATTRIBUTES' ? size % 4 !== 0 : (size !== 2 && size !== 4) || filter !== 'NONE'
+      || (mode === 'TRIANGLES' && elements % 3 !== 0)) throw new Error('Invalid GLB meshopt stride or mode');
+    if ((filter === 'OCTAHEDRAL' && size !== 4 && size !== 8) || (filter === 'QUATERNION' && size !== 8)) throw new Error('Invalid GLB meshopt filter');
+    return { view, offset, length, source: physical.subarray(sourceOffset, sourceOffset + sourceLength), codec: { elements, size, mode, filter } };
+  });
+  if (!rows.some(row => row.codec !== undefined)) return { views, bytes: physical, decoded: 0 };
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  const normalized = rows.map(row => {
+    const target = bytes.subarray(offset, offset + row.length);
+    if (row.codec === undefined) target.set(row.source);
+    else MeshoptDecoder.decodeGltfBuffer(target, row.codec.elements, row.codec.size, row.source, row.codec.mode, row.codec.filter);
+    const view = row.view;
+    view['buffer'] = 0; view['byteOffset'] = offset;
+    offset += row.length;
+    return view;
+  });
+  return { views: normalized, bytes, decoded: total };
+}