@fulcro/types 0.1.0 → 0.2.0

package/LICENSE

@@ -1,15 +1,15 @@
-ISC License
-
-Copyright (c) 2026 diguu <rodrigogeribola@hotmail.com>
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
+ISC License
+
+Copyright (c) 2026 diguu <rodrigogeribola@hotmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -1,66 +1,86 @@
-# @fulcro/types
-
-Numeric types with a declared range and layout: fixed-width integers, half,
-single and double precision floats, an integer of any size, and a `Decimal` with
-the semantics of IEEE 754 decimal128 — with the JavaScript operators working on
-every one of them once the plugin is wired up.
-
-```sh
-npm install @fulcro/types
-```
-
-```ts
-import { Decimal, SignedInteger, UnsignedInteger } from '@fulcro/types';
-
-const Int32 = SignedInteger(32);
-
-Int32.add(Int32.from(2), Int32.from(3)); // 5
-Int32.add(Int32.maximum, Int32.from(1)); // RangeError: outside [-2147483648, 2147483647]
-UnsignedInteger(8).wrap(-1); // 255, when modular arithmetic is what you mean
-
-Decimal.from('0.1').add(Decimal.from('0.2')).toString(); // '0.3'
-Decimal.from('19.99').multiply(Decimal.from(3)).toString(); // '59.97'
-```
-
-| Type                                         | What it is                                         |
-| -------------------------------------------- | -------------------------------------------------- |
-| `SignedInteger<N>`, `UnsignedInteger<N>`     | 8 to 128 bits, checked arithmetic, `wrap`          |
-| `HalfPrecisionFloat`, `SinglePrecisionFloat` | binary16 and binary32, each operation rounded once |
-| `DoublePrecisionFloat`                       | binary64, the `number` named as a choice           |
-| `BigInteger`                                 | an integer of any size                             |
-| `Decimal`                                    | 34 decimal digits, five rounding modes             |
-
-Each type has a value of the same name that converts, recognises and computes,
-and every type but `BigInteger` reports its `minimum` and `maximum`. If you only
-need the types, `import type` them and no code is loaded.
-
-## Operators
-
-With the plugin, the operators mean what the type means — checked on an
-integer, rounded on a float, decimal128 on a `Decimal` — and the result keeps
-its type. Both operands have to be the same type, or it is a type error at the
-line:
-
-```ts
-const total = price * Decimal.from(3); // Decimal
-count++; // SignedInteger<32>.increment, checked
-a + 1; // type error: 'number' is not 'SignedInteger<32>'
-```
-
-| Tool       | Wire in                                                                                  |
-| ---------- | ---------------------------------------------------------------------------------------- |
-| `tsc`      | `{ "transform": "@fulcro/types/transformer", "transformProgram": true }`, via `ts-patch` |
-| A bundler  | `vite` (or `rollup`, `webpack`, `esbuild`, …) from `@fulcro/types/unplugin`              |
-| The editor | `{ "name": "@fulcro/types/language-service" }` in the tsconfig `plugins`                 |
-
-Without it, the operators are the language's own: unchecked on the
-`number`-backed types, refused on a `Decimal`.
-
-Every type but `BigInteger` declares a size and alignment, which
-`sizeOf<T>()` and `alignOf<T>()` from `@fulcro/reflect` read at compile time.
-
----
-
-**Full guide:** [docs/types.md](../../docs/types.md) — ranges, rounding, the
-operators, the special values and the layout table.
-🇧🇷 [Leia em português](../../docs/pt-BR/types.md).
+# @fulcro/types
+
+Numeric types with a declared range and layout: fixed-width integers, half,
+single and double precision floats, an integer of any size, and a `Decimal` with
+the semantics of IEEE 754 decimal128 — with the JavaScript operators working on
+every one of them once the plugin is wired up.
+
+```sh
+npm install @fulcro/types
+```
+
+```ts
+import { Decimal, SignedInteger, UnsignedInteger } from '@fulcro/types';
+
+const Int32 = SignedInteger(32);
+
+Int32.add(Int32.from(2), Int32.from(3)); // 5
+Int32.add(Int32.maximum, Int32.from(1)); // RangeError: outside [-2147483648, 2147483647]
+UnsignedInteger(8).wrap(-1); // 255, when modular arithmetic is what you mean
+
+Decimal.from('0.1').add(Decimal.from('0.2')).toString(); // '0.3'
+Decimal.from('19.99').multiply(Decimal.from(3)).toString(); // '59.97'
+```
+
+| Type                                         | What it is                                         |
+| -------------------------------------------- | -------------------------------------------------- |
+| `SignedInteger<N>`, `UnsignedInteger<N>`     | 8 to 128 bits, checked arithmetic, `wrap`          |
+| `HalfPrecisionFloat`, `SinglePrecisionFloat` | binary16 and binary32, each operation rounded once |
+| `DoublePrecisionFloat`                       | binary64, the `number` named as a choice           |
+| `BigInteger`                                 | an integer of any size                             |
+| `Decimal`                                    | 34 decimal digits, five rounding modes             |
+
+Each type has a value of the same name that converts, recognises and computes,
+and every type but `BigInteger` reports its `minimum` and `maximum`. If you only
+need the types, `import type` them and no code is loaded.
+
+## Operators
+
+With the plugin, the operators mean what the type means — checked on an
+integer, rounded on a float, decimal128 on a `Decimal` — and the result keeps
+its type. Both operands have to be the same type, or it is a type error at the
+line:
+
+```ts
+const total = price * Decimal.from(3); // Decimal
+count++; // SignedInteger<32>.increment, checked
+a + 1; // type error: 'number' is not 'SignedInteger<32>'
+```
+
+| Tool       | Wire in                                                                                  |
+| ---------- | ---------------------------------------------------------------------------------------- |
+| `tsc`      | `{ "transform": "@fulcro/types/transformer", "transformProgram": true }`, via `ts-patch` |
+| A bundler  | `vite` (or `rollup`, `webpack`, `esbuild`, …) from `@fulcro/types/unplugin`              |
+| The editor | `{ "name": "@fulcro/types/language-service" }` in the tsconfig `plugins`                 |
+
+Without it, the operators are the language's own: unchecked on the
+`number`-backed types, refused on a `Decimal`.
+
+Every type but `BigInteger` declares a size and alignment, which
+`sizeOf<T>()` and `alignOf<T>()` from `@fulcro/reflect` read at compile time.
+
+## Structs
+
+Value types with a fixed layout, built from the types above and from each
+other — frozen, compared by field, and stored in a `DataView` without an object
+per value:
+
+```ts
+import { SinglePrecisionFloat, struct, type Struct } from '@fulcro/types';
+
+const Vector3 = struct('Vector3', {
+	x: SinglePrecisionFloat,
+	y: SinglePrecisionFloat,
+	z: SinglePrecisionFloat,
+});
+type Vector3 = Struct<typeof Vector3>;
+
+Vector3.layout.size; // 12, and sizeOf<Vector3>() at compile time
+Vector3.write(view, 0, Vector3.from({ x: 0, y: 1, z: 0 }));
+```
+
+---
+
+**Full guide:** [docs/types.md](../../docs/types.md) — ranges, rounding, the
+operators, the special values, the layout table and structs.
+🇧🇷 [Leia em português](../../docs/pt-BR/types.md).

package/dist/index.d.ts

@@ -19,4 +19,6 @@ export type { BoundedNumericType, NumericType } from './numericType/index.js';
 export type { RoundingMode } from './roundingMode/index.js';
 export { SignedInteger } from './signedInteger/index.js';
 export { SinglePrecisionFloat } from './singlePrecisionFloat/index.js';
+export type { Struct, StructType } from './struct/index.js';
+export { struct } from './struct/index.js';
 export { UnsignedInteger } from './unsignedInteger/index.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnsignedInteger = exports.SinglePrecisionFloat = exports.SignedInteger = exports.HalfPrecisionFloat = exports.DoublePrecisionFloat = exports.Decimal = exports.BigInteger = void 0;
+exports.UnsignedInteger = exports.struct = exports.SinglePrecisionFloat = exports.SignedInteger = exports.HalfPrecisionFloat = exports.DoublePrecisionFloat = exports.Decimal = exports.BigInteger = void 0;
 /**
  * Public entry point of the package, matching the `main` and `types` fields of
  * `package.json`.
@@ -25,5 +25,7 @@ var signedInteger_1 = require("./signedInteger/index.js");
 Object.defineProperty(exports, "SignedInteger", { enumerable: true, get: function () { return signedInteger_1.SignedInteger; } });
 var singlePrecisionFloat_1 = require("./singlePrecisionFloat/index.js");
 Object.defineProperty(exports, "SinglePrecisionFloat", { enumerable: true, get: function () { return singlePrecisionFloat_1.SinglePrecisionFloat; } });
+var struct_1 = require("./struct/index.js");
+Object.defineProperty(exports, "struct", { enumerable: true, get: function () { return struct_1.struct; } });
 var unsignedInteger_1 = require("./unsignedInteger/index.js");
 Object.defineProperty(exports, "UnsignedInteger", { enumerable: true, get: function () { return unsignedInteger_1.UnsignedInteger; } });

package/dist/struct/arithmetic.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Arithmetic on number literals, at the type level, for the layout a struct
+ * type declares.
+ *
+ * `sizeOf<T>()` answers from the literal in `T['~layout']`, so a struct type
+ * has to carry its size as a literal, and that literal is a sum of its fields
+ * rounded up to its alignment. TypeScript has no arithmetic on literals; this
+ * module is the smallest amount of it the layout needs.
+ *
+ * Addition works digit by digit on the decimal text of a number, so it is not
+ * bounded by the recursion limit the way counting a tuple up to the sum would
+ * be. Rounding needs a remainder, and the remainder by an alignment — a power
+ * of two up to sixteen — depends only on the last four digits, since sixteen
+ * divides ten thousand; so no tuple built here is ever longer than 9,999.
+ *
+ * Wherever an input is `number` rather than a literal, the answer is `number`:
+ * `sizeOf` then refuses the type rather than report a wrong size.
+ */
+/** A decimal digit, as text. */
+type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+/** The value of each digit. */
+interface DigitValues {
+    readonly '0': 0;
+    readonly '1': 1;
+    readonly '2': 2;
+    readonly '3': 3;
+    readonly '4': 4;
+    readonly '5': 5;
+    readonly '6': 6;
+    readonly '7': 7;
+    readonly '8': 8;
+    readonly '9': 9;
+}
+/**
+ * A tuple of `N` elements, for the small `N` a digit or an alignment needs.
+ *
+ * @template N Length, from 0 to 19.
+ */
+type Units<N extends number, TAccumulated extends unknown[] = []> = TAccumulated['length'] extends N ? TAccumulated : Units<N, [...TAccumulated, unknown]>;
+/** Ten elements, the carry out of a digit. */
+type Ten = Units<10>;
+/**
+ * Adds two digits and a carry.
+ *
+ * @template TLeft First digit.
+ * @template TRight Second digit.
+ * @template TCarry Carry into this digit.
+ * @returns `[digit, carry]` of the sum.
+ */
+type AddDigits<TLeft extends Digit, TRight extends Digit, TCarry extends 0 | 1> = [
+    ...Units<DigitValues[TLeft]>,
+    ...Units<DigitValues[TRight]>,
+    ...Units<TCarry>
+] extends infer TAll extends unknown[] ? TAll extends [...Ten, ...infer TRest] ? [`${TRest['length']}`, 1] : [`${TAll['length']}`, 0] : never;
+/** First character of a text, `'0'` once it is empty. */
+type Head<TText extends string> = TText extends `${infer THead extends Digit}${string}` ? THead : '0';
+/** A text without its first character. */
+type Tail<TText extends string> = TText extends `${Digit}${infer TTail}` ? TTail : '';
+/**
+ * Adds two numbers written least significant digit first.
+ *
+ * @returns The sum, least significant digit first.
+ */
+type AddReversed<TLeft extends string, TRight extends string, TCarry extends 0 | 1 = 0, TSum extends string = ''> = TLeft extends '' ? TRight extends '' ? TCarry extends 1 ? `${TSum}1` : TSum : AddStep<TLeft, TRight, TCarry, TSum> : AddStep<TLeft, TRight, TCarry, TSum>;
+/** One digit of {@link AddReversed}. */
+type AddStep<TLeft extends string, TRight extends string, TCarry extends 0 | 1, TSum extends string> = AddDigits<Head<TLeft>, Head<TRight>, TCarry> extends [
+    infer TDigit extends string,
+    infer TNext extends 0 | 1
+] ? AddReversed<Tail<TLeft>, Tail<TRight>, TNext, `${TSum}${TDigit}`> : never;
+/** A text, backwards. */
+type Reverse<TText extends string, TReversed extends string = ''> = TText extends `${infer THead}${infer TTail}` ? Reverse<TTail, `${THead}${TReversed}`> : TReversed;
+/** The number a text of digits spells. */
+type ToNumber<TText extends string> = TText extends `${infer N extends number}` ? N : never;
+/**
+ * The sum of two number literals; `number` when either is not a literal.
+ *
+ * @template TLeft First operand, a non-negative integer.
+ * @template TRight Second operand, a non-negative integer.
+ */
+export type Add<TLeft extends number, TRight extends number> = number extends TLeft | TRight ? number : ToNumber<Reverse<AddReversed<Reverse<`${TLeft}`>, Reverse<`${TRight}`>>>>;
+/**
+ * A tuple as long as a number of up to four digits, built one digit at a time
+ * — ten copies of what came before, and the digit — so its depth is the number
+ * of digits rather than the number itself.
+ */
+type TupleOf<TDigits extends string, TAccumulated extends unknown[] = []> = TDigits extends `${infer THead extends Digit}${infer TTail}` ? TupleOf<TTail, [
+    ...TAccumulated,
+    ...TAccumulated,
+    ...TAccumulated,
+    ...TAccumulated,
+    ...TAccumulated,
+    ...TAccumulated,
+    ...TAccumulated,
+    ...TAccumulated,
+    ...TAccumulated,
+    ...TAccumulated,
+    ...Units<DigitValues[THead]>
+]> : TAccumulated;
+/** The last `N` characters of a text written least significant first. */
+type Take<TText extends string, N extends number, TTaken extends string = '', TCount extends unknown[] = []> = TCount['length'] extends N ? TTaken : TText extends `${infer THead}${infer TTail}` ? Take<TTail, N, `${THead}${TTaken}`, [...TCount, unknown]> : TTaken;
+/** Digits of a number that decide its remainder by each alignment. */
+interface RemainderDigits {
+    readonly 2: 1;
+    readonly 4: 2;
+    readonly 8: 3;
+    readonly 16: 4;
+}
+/** How many elements are left of a tuple once whole chunks are taken off it. */
+type Leftover<TTuple extends unknown[], TChunk extends unknown[]> = TTuple extends [...TChunk, ...infer TRest] ? Leftover<TRest, TChunk> : TTuple['length'];
+/**
+ * The remainder of a number by an alignment.
+ *
+ * @template N A non-negative integer literal.
+ * @template TAlignment 2, 4, 8 or 16.
+ */
+type Remainder<N extends number, TAlignment extends keyof RemainderDigits> = Leftover<TupleOf<Take<Reverse<`${N}`>, RemainderDigits[TAlignment]>>, Units<TAlignment>>;
+/**
+ * A number rounded up to a multiple of an alignment: the size of a struct once
+ * its tail padding is added.
+ *
+ * @template N Size before padding.
+ * @template TAlignment Alignment of the struct, a power of two up to 16.
+ */
+export type RoundUp<N extends number, TAlignment extends number> = number extends N | TAlignment ? number : TAlignment extends keyof RemainderDigits ? Remainder<N, TAlignment> extends infer TRemainder extends number ? TRemainder extends 0 ? N : Units<TAlignment> extends [...Units<TRemainder>, ...infer TPadding] ? Add<N, TPadding['length']> : never : never : N;
+/**
+ * The largest of a union of alignments.
+ *
+ * @template TAlignments Alignments of the fields, each a power of two up to 16.
+ */
+export type LargestAlignment<TAlignments extends number> = number extends TAlignments ? number : 16 extends TAlignments ? 16 : 8 extends TAlignments ? 8 : 4 extends TAlignments ? 4 : 2 extends TAlignments ? 2 : 1;
+export {};

package/dist/struct/arithmetic.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Arithmetic on number literals, at the type level, for the layout a struct
+ * type declares.
+ *
+ * `sizeOf<T>()` answers from the literal in `T['~layout']`, so a struct type
+ * has to carry its size as a literal, and that literal is a sum of its fields
+ * rounded up to its alignment. TypeScript has no arithmetic on literals; this
+ * module is the smallest amount of it the layout needs.
+ *
+ * Addition works digit by digit on the decimal text of a number, so it is not
+ * bounded by the recursion limit the way counting a tuple up to the sum would
+ * be. Rounding needs a remainder, and the remainder by an alignment — a power
+ * of two up to sixteen — depends only on the last four digits, since sixteen
+ * divides ten thousand; so no tuple built here is ever longer than 9,999.
+ *
+ * Wherever an input is `number` rather than a literal, the answer is `number`:
+ * `sizeOf` then refuses the type rather than report a wrong size.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/struct/codec.d.ts

@@ -0,0 +1,58 @@
+/**
+ * How a field of a struct is laid out in bytes, and how it is compared.
+ *
+ * Internal. A struct is built from descriptors, and a descriptor says how a
+ * value is checked but not how it is stored — `SinglePrecisionFloat` has no
+ * byte order. The codec is what a struct looks up for each field, by the
+ * identity of its descriptor, so the numeric types did not have to grow a
+ * public byte encoding for this.
+ *
+ * Every multi-byte value is little-endian, whatever the platform: bytes a
+ * struct writes on one machine read back the same on any other, and it is the
+ * order of every platform a JavaScript engine runs on in practice.
+ */
+export interface FieldCodec {
+    /** Size, in bytes. */
+    readonly size: number;
+    /** Alignment, in bytes. */
+    readonly alignment: number;
+    /**
+     * Reads a value.
+     *
+     * @param view Bytes to read from.
+     * @param offset Where the value starts.
+     * @returns The value.
+     */
+    read(view: DataView, offset: number): unknown;
+    /**
+     * Writes a value.
+     *
+     * @param view Bytes to write into.
+     * @param offset Where the value starts.
+     * @param value The value, already of the field's type.
+     */
+    write(view: DataView, offset: number, value: unknown): void;
+    /**
+     * Compares two values as the field's own type does.
+     *
+     * @param left First value.
+     * @param right Second value.
+     * @returns `true` when they are equal.
+     */
+    equals(left: unknown, right: unknown): boolean;
+}
+/**
+ * Registers the codec of a struct, so that another struct can hold it as a
+ * field.
+ *
+ * @param descriptor Descriptor of the struct.
+ * @param codec How it is stored.
+ */
+export declare const registerStructCodec: (descriptor: object, codec: FieldCodec) => void;
+/**
+ * The codec of a field's descriptor.
+ *
+ * @param descriptor What the field was declared with.
+ * @returns Its codec, or `undefined` for a descriptor with no fixed layout.
+ */
+export declare const codecOf: (descriptor: unknown) => FieldCodec | undefined;

package/dist/struct/codec.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codecOf = exports.registerStructCodec = void 0;
+const decimal_1 = require("../decimal/index.js");
+const format_1 = require("../decimal/format.js");
+const parse_1 = require("../decimal/parse.js");
+const parts_1 = require("../decimal/parts.js");
+const doublePrecisionFloat_1 = require("../doublePrecisionFloat/index.js");
+const halfPrecisionFloat_1 = require("../halfPrecisionFloat/index.js");
+const signedInteger_1 = require("../signedInteger/index.js");
+const singlePrecisionFloat_1 = require("../singlePrecisionFloat/index.js");
+const unsignedInteger_1 = require("../unsignedInteger/index.js");
+/** Bits of a 64-bit half of a 128-bit value. */
+const HALF_WIDTH = 64n;
+/**
+ * The codec of a 128-bit integer, as two 64-bit halves, low half first.
+ *
+ * @param descriptor Descriptor of the width.
+ * @returns The codec.
+ */
+const integer128Codec = (descriptor) => ({
+    size: 16,
+    alignment: 16,
+    read: (view, offset) => {
+        const low = view.getBigUint64(offset, true);
+        const high = descriptor.signed
+            ? view.getBigInt64(offset + 8, true)
+            : view.getBigUint64(offset + 8, true);
+        return (high << HALF_WIDTH) | low;
+    },
+    write: (view, offset, value) => {
+        view.setBigUint64(offset, BigInt.asUintN(64, value), true);
+        view.setBigUint64(offset + 8, BigInt.asUintN(64, value >> HALF_WIDTH), true);
+    },
+    equals: (left, right) => descriptor.equals(left, right),
+});
+/**
+ * The codec of a fixed-width integer, through the `DataView` accessor of its
+ * width, or two of them at 128 bits.
+ *
+ * @param descriptor Descriptor of the width.
+ * @returns The codec.
+ */
+const integerCodec = (descriptor) => {
+    const { signed, width } = descriptor;
+    if (width === 128)
+        return integer128Codec(descriptor);
+    const size = width / 8;
+    const equals = (left, right) => descriptor.equals(left, right);
+    switch (width) {
+        case 8:
+            return {
+                size,
+                alignment: size,
+                read: (view, offset) => signed ? view.getInt8(offset) : view.getUint8(offset),
+                write: (view, offset, value) => signed
+                    ? view.setInt8(offset, value)
+                    : view.setUint8(offset, value),
+                equals,
+            };
+        case 16:
+            return {
+                size,
+                alignment: size,
+                read: (view, offset) => signed ? view.getInt16(offset, true) : view.getUint16(offset, true),
+                write: (view, offset, value) => signed
+                    ? view.setInt16(offset, value, true)
+                    : view.setUint16(offset, value, true),
+                equals,
+            };
+        case 32:
+            return {
+                size,
+                alignment: size,
+                read: (view, offset) => signed ? view.getInt32(offset, true) : view.getUint32(offset, true),
+                write: (view, offset, value) => signed
+                    ? view.setInt32(offset, value, true)
+                    : view.setUint32(offset, value, true),
+                equals,
+            };
+        default:
+            return {
+                size,
+                alignment: size,
+                read: (view, offset) => signed
+                    ? view.getBigInt64(offset, true)
+                    : view.getBigUint64(offset, true),
+                write: (view, offset, value) => signed
+                    ? view.setBigInt64(offset, value, true)
+                    : view.setBigUint64(offset, value, true),
+                equals,
+            };
+    }
+};
+/** Exponent of the smallest normal half precision value. */
+const HALF_MINIMUM_NORMAL_EXPONENT = -14;
+/** Spacing of the half precision subnormals, 2^-24. */
+const HALF_SUBNORMAL_SPACING = 2 ** -24;
+/**
+ * The binary16 bit pattern of a half precision value.
+ *
+ * Written here rather than delegated to `DataView.prototype.setFloat16`, which
+ * Node 22 — the oldest line this package supports — does not have. The value
+ * is already exactly representable, so every division below is exact and
+ * nothing is rounded: this only rearranges bits.
+ *
+ * @param value A half precision value.
+ * @returns Its sixteen bits.
+ */
+const encodeHalf = (value) => {
+    if (Number.isNaN(value))
+        return 0x7e00;
+    const sign = value < 0 || Object.is(value, -0) ? 0x8000 : 0;
+    const magnitude = Math.abs(value);
+    if (magnitude === Infinity)
+        return sign | 0x7c00;
+    if (magnitude < 2 ** HALF_MINIMUM_NORMAL_EXPONENT) {
+        return sign | (magnitude / HALF_SUBNORMAL_SPACING);
+    }
+    // `Math.log2` is not exact next to a power of two, so the estimate is
+    // corrected against the power itself.
+    let exponent = Math.floor(Math.log2(magnitude));
+    if (2 ** exponent > magnitude)
+        exponent--;
+    else if (2 ** (exponent + 1) <= magnitude)
+        exponent++;
+    return (sign | ((exponent + 15) << 10) | ((magnitude / 2 ** exponent - 1) * 1024));
+};
+/**
+ * The half precision value of a binary16 bit pattern.
+ *
+ * @param bits Sixteen bits.
+ * @returns The value they encode.
+ */
+const decodeHalf = (bits) => {
+    const sign = bits & 0x8000 ? -1 : 1;
+    const exponent = (bits >> 10) & 0x1f;
+    const fraction = bits & 0x3ff;
+    if (exponent === 0)
+        return sign * fraction * HALF_SUBNORMAL_SPACING;
+    if (exponent === 0x1f)
+        return fraction === 0 ? sign * Infinity : NaN;
+    return sign * (1 + fraction / 1024) * 2 ** (exponent - 15);
+};
+/** The codecs of the three binary float formats, by descriptor. */
+const floatCodecs = new Map([
+    [
+        halfPrecisionFloat_1.HalfPrecisionFloat,
+        {
+            size: 2,
+            alignment: 2,
+            read: (view, offset) => decodeHalf(view.getUint16(offset, true)),
+            write: (view, offset, value) => view.setUint16(offset, encodeHalf(value), true),
+            equals: (left, right) => halfPrecisionFloat_1.HalfPrecisionFloat.equals(left, right),
+        },
+    ],
+    [
+        singlePrecisionFloat_1.SinglePrecisionFloat,
+        {
+            size: 4,
+            alignment: 4,
+            read: (view, offset) => view.getFloat32(offset, true),
+            write: (view, offset, value) => view.setFloat32(offset, value, true),
+            equals: (left, right) => singlePrecisionFloat_1.SinglePrecisionFloat.equals(left, right),
+        },
+    ],
+    [
+        doublePrecisionFloat_1.DoublePrecisionFloat,
+        {
+            size: 8,
+            alignment: 8,
+            read: (view, offset) => view.getFloat64(offset, true),
+            write: (view, offset, value) => view.setFloat64(offset, value, true),
+            equals: (left, right) => doublePrecisionFloat_1.DoublePrecisionFloat.equals(left, right),
+        },
+    ],
+]);
+/** Bias of the decimal128 exponent: the stored field is `exponent + 6176`. */
+const DECIMAL_EXPONENT_BIAS = 6176;
+/**
+ * Largest exponent a decimal128 coefficient can be scaled by: the largest
+ * value, thirty-four nines, has its last digit at 10^6111.
+ */
+const DECIMAL_MAXIMUM_EXPONENT = 6111;
+/** Bits of the decimal128 coefficient field. */
+const DECIMAL_COEFFICIENT_BITS = 113n;
+/** The coefficients a decimal128 holds are below this; above it is non-canonical. */
+const DECIMAL_COEFFICIENT_LIMIT = (0, parts_1.powerOfTen)(34);
+/**
+ * The decimal128 bits of a decimal, in the binary integer decimal encoding
+ * IEEE 754-2008 defines: a sign bit, fourteen bits of biased exponent and a
+ * 113-bit binary coefficient.
+ *
+ * The parts are normalised, which can leave a large value with a short
+ * coefficient and an exponent past the one the format stores — 1 × 10^6144.
+ * Those are scaled back into range by moving digits into the coefficient,
+ * which always has room for them because the value is within range.
+ *
+ * @param parts The value.
+ * @returns Its 128 bits.
+ */
+const encodeDecimal = (parts) => {
+    const sign = parts.negative ? 1n << 127n : 0n;
+    if (parts.kind === 'nan')
+        return 0x7c00000000000000n << HALF_WIDTH;
+    if (parts.kind === 'infinity') {
+        return sign | (0x7800000000000000n << HALF_WIDTH);
+    }
+    let { coefficient, exponent } = parts;
+    if (exponent > DECIMAL_MAXIMUM_EXPONENT) {
+        coefficient *= (0, parts_1.powerOfTen)(exponent - DECIMAL_MAXIMUM_EXPONENT);
+        exponent = DECIMAL_MAXIMUM_EXPONENT;
+    }
+    return (sign |
+        (BigInt(exponent + DECIMAL_EXPONENT_BIAS) << DECIMAL_COEFFICIENT_BITS) |
+        coefficient);
+};
+/**
+ * The decimal of decimal128 bits.
+ *
+ * A coefficient past thirty-four digits — including every one written in the
+ * encoding's second form, whose leading bits are `11` — is non-canonical, and
+ * IEEE 754 reads it as zero. Trailing zeros are moved into the exponent, which
+ * is the normalised form every `Decimal` holds.
+ *
+ * @param bits 128 bits.
+ * @returns The parts they encode.
+ */
+const decodeDecimal = (bits) => {
+    const negative = bits >> 127n === 1n;
+    const combination = (bits >> 122n) & 0x1fn;
+    if (combination === 0x1fn) {
+        return { kind: 'nan', negative: false, coefficient: 0n, exponent: 0 };
+    }
+    if (combination === 0x1en) {
+        return { kind: 'infinity', negative, coefficient: 0n, exponent: 0 };
+    }
+    let coefficient = ((bits >> 125n) & 0x3n) === 0x3n
+        ? 0n
+        : bits & ((1n << DECIMAL_COEFFICIENT_BITS) - 1n);
+    if (coefficient >= DECIMAL_COEFFICIENT_LIMIT)
+        coefficient = 0n;
+    if (coefficient === 0n) {
+        return { kind: 'finite', negative, coefficient: 0n, exponent: 0 };
+    }
+    let exponent = Number((bits >> DECIMAL_COEFFICIENT_BITS) & 0x3fffn) -
+        DECIMAL_EXPONENT_BIAS;
+    while (coefficient % 10n === 0n) {
+        coefficient /= 10n;
+        exponent++;
+    }
+    return { kind: 'finite', negative, coefficient, exponent };
+};
+/**
+ * The codec of `Decimal`, as decimal128.
+ *
+ * Its parts are private to the class, so they travel through its text, which
+ * reads back exactly: the shortest text of a normalised value names exactly
+ * that value.
+ */
+const decimalCodec = {
+    size: 16,
+    alignment: 16,
+    read: (view, offset) => {
+        const bits = (view.getBigUint64(offset + 8, true) << HALF_WIDTH) |
+            view.getBigUint64(offset, true);
+        return decimal_1.Decimal.from((0, format_1.formatDecimal)(decodeDecimal(bits)));
+    },
+    write: (view, offset, value) => {
+        const bits = encodeDecimal((0, parse_1.parseDecimal)(String(value)));
+        view.setBigUint64(offset, BigInt.asUintN(64, bits), true);
+        view.setBigUint64(offset + 8, bits >> HALF_WIDTH, true);
+    },
+    equals: (left, right) => left.equals(right),
+};
+/** Codecs registered by the structs themselves, so one can nest in another. */
+const structCodecs = new WeakMap();
+/** Widths a fixed-width integer comes in. */
+const INTEGER_WIDTHS = [8, 16, 32, 64, 128];
+/**
+ * Tells whether a value is the descriptor `SignedInteger` or `UnsignedInteger`
+ * returns for its width — the same object, not one shaped like it.
+ *
+ * @param descriptor Value to inspect.
+ * @returns `true` for an integer descriptor of this package.
+ */
+const isIntegerDescriptor = (descriptor) => {
+    const { signed, width } = descriptor;
+    if (typeof signed !== 'boolean' || !INTEGER_WIDTHS.includes(width)) {
+        return false;
+    }
+    const factory = signed ? signedInteger_1.SignedInteger : unsignedInteger_1.UnsignedInteger;
+    return factory(width) === descriptor;
+};
+/**
+ * Registers the codec of a struct, so that another struct can hold it as a
+ * field.
+ *
+ * @param descriptor Descriptor of the struct.
+ * @param codec How it is stored.
+ */
+const registerStructCodec = (descriptor, codec) => {
+    structCodecs.set(descriptor, codec);
+};
+exports.registerStructCodec = registerStructCodec;
+/**
+ * The codec of a field's descriptor.
+ *
+ * @param descriptor What the field was declared with.
+ * @returns Its codec, or `undefined` for a descriptor with no fixed layout.
+ */
+const codecOf = (descriptor) => {
+    if (typeof descriptor !== 'object' && typeof descriptor !== 'function') {
+        return undefined;
+    }
+    if (descriptor === null)
+        return undefined;
+    if (descriptor === decimal_1.Decimal)
+        return decimalCodec;
+    const known = floatCodecs.get(descriptor) ?? structCodecs.get(descriptor);
+    if (known !== undefined)
+        return known;
+    return isIntegerDescriptor(descriptor) ? integerCodec(descriptor) : undefined;
+};
+exports.codecOf = codecOf;

package/dist/struct/index.d.ts

@@ -0,0 +1,174 @@
+import type { Layout } from '../layout/index.js';
+import type { Add, LargestAlignment, RoundUp } from './arithmetic.js';
+/**
+ * What a field of a struct may be declared with: the descriptor of a type that
+ * declares a fixed layout — a numeric type of this package other than
+ * `BigInteger`, or another struct.
+ */
+interface FieldDescriptor {
+    is(value: unknown): value is Layout<number, number>;
+}
+/** The fields of a struct, by name, in declaration order. */
+type StructFields = {
+    readonly [field: string]: FieldDescriptor;
+};
+/** The type of the values a descriptor recognises. */
+type ValueOf<TDescriptor> = TDescriptor extends {
+    is(value: unknown): value is infer T;
+} ? T : never;
+/** What a descriptor's `from` accepts. */
+type SourceOf<TDescriptor> = TDescriptor extends {
+    from(value: infer TSource): unknown;
+} ? TSource : never;
+/** The layout a field's type declares. */
+type FieldLayout<TDescriptor> = ValueOf<TDescriptor> extends Layout<infer TSize, infer TAlignment> ? {
+    readonly size: TSize;
+    readonly alignment: TAlignment;
+} : never;
+/** A union, as a tuple in no particular order — enough to sum over it. */
+type UnionToTuple<TUnion, TTuple extends unknown[] = []> = [TUnion] extends [
+    never
+] ? TTuple : UnionToTuple<Exclude<TUnion, LastOf<TUnion>>, [LastOf<TUnion>, ...TTuple]>;
+/** One member of a union, picked by how TypeScript orders overloads. */
+type LastOf<TUnion> = (TUnion extends unknown ? (member: () => TUnion) => void : never) extends (member: infer TIntersection) => void ? TIntersection extends () => infer TMember ? TMember : never : never;
+/** The sizes of some fields, added up. */
+type SumOfSizes<TFields extends StructFields, TKeys extends unknown[], TSum extends number = 0> = TKeys extends [infer TKey extends keyof TFields, ...infer TRest] ? SumOfSizes<TFields, TRest, Add<TSum, FieldLayout<TFields[TKey]>['size']>> : TSum;
+/** Alignment of a struct: the largest alignment of its fields. */
+type StructAlignment<TFields extends StructFields> = LargestAlignment<{
+    [TKey in keyof TFields]: FieldLayout<TFields[TKey]>['alignment'];
+}[keyof TFields]>;
+/**
+ * Size of a struct: its fields, which pack without padding once ordered by
+ * alignment, rounded up to its alignment. Independent of the order the fields
+ * were declared in, which is why it can be computed here at all — a type does
+ * not promise an order for its keys.
+ */
+type StructSize<TFields extends StructFields> = RoundUp<SumOfSizes<TFields, UnionToTuple<keyof TFields>>, StructAlignment<TFields>>;
+/** A value of a struct. */
+type StructValue<TFields extends StructFields> = {
+    readonly [TKey in keyof TFields]: ValueOf<TFields[TKey]>;
+} & Layout<StructSize<TFields>, StructAlignment<TFields>>;
+/** What a struct's `from` accepts: each field in what its own `from` accepts. */
+type StructSource<TFields extends StructFields> = {
+    readonly [TKey in keyof TFields]: SourceOf<TFields[TKey]>;
+};
+/**
+ * The descriptor of a struct: its layout, and how its values are made,
+ * recognised, compared and stored.
+ *
+ * @template TFields Descriptors of the fields, by name.
+ */
+export interface StructType<TFields extends StructFields> {
+    /** Name of the struct, as it reads in an error message. */
+    readonly name: string;
+    /**
+     * Where each field sits and how much room the struct takes.
+     *
+     * Fields are placed by alignment, largest first, and in declaration order
+     * among equals — so no field needs padding before it, and only the end of
+     * the struct is padded, up to its alignment, so that the next one in an
+     * array starts aligned. `size` and `alignment` are the numbers
+     * `sizeOf<T>()` and `alignOf<T>()` report.
+     */
+    readonly layout: {
+        readonly size: StructSize<TFields>;
+        readonly alignment: StructAlignment<TFields>;
+        readonly fields: {
+            readonly [TKey in keyof TFields]: {
+                readonly offset: number;
+                readonly size: FieldLayout<TFields[TKey]>['size'];
+                readonly alignment: FieldLayout<TFields[TKey]>['alignment'];
+            };
+        };
+    };
+    /**
+     * Makes a value, converting each field with its own type's `from`.
+     *
+     * @param source One entry per field, and nothing else.
+     * @returns The value, frozen.
+     * @throws {TypeError} When a field is missing or not a field of the struct.
+     * @throws {RangeError} When a field's own conversion refuses its value; the
+     * message names the field, and `cause` is the original error.
+     */
+    from(source: StructSource<TFields>): StructValue<TFields>;
+    /**
+     * Tells whether a value is one of this struct's: frozen, with exactly its
+     * fields, each of its type.
+     *
+     * @param value Value to inspect.
+     * @returns `true` when it is.
+     */
+    is(value: unknown): value is StructValue<TFields>;
+    /**
+     * Compares two values field by field, each as its own type compares — so a
+     * `NaN` field makes a value unequal to itself, as it does in C#.
+     *
+     * @param left First value.
+     * @param right Second value.
+     * @returns `true` when every field is equal.
+     */
+    equals(left: StructValue<TFields>, right: StructValue<TFields>): boolean;
+    /**
+     * Reads a value from bytes, in the layout of {@link StructType.layout},
+     * little-endian.
+     *
+     * @param view Bytes to read from.
+     * @param offset Where the value starts.
+     * @returns The value, frozen.
+     * @throws {RangeError} When the struct does not fit in the view at that
+     * offset.
+     */
+    read(view: DataView, offset: number): StructValue<TFields>;
+    /**
+     * Writes a value into bytes, in the layout of {@link StructType.layout},
+     * little-endian. Padding bytes are left as they were.
+     *
+     * @param view Bytes to write into.
+     * @param offset Where the value starts.
+     * @param value Value to write.
+     * @throws {RangeError} When the struct does not fit in the view at that
+     * offset.
+     */
+    write(view: DataView, offset: number, value: StructValue<TFields>): void;
+}
+/**
+ * The type of the values of a struct, named from its descriptor.
+ *
+ * ```ts
+ * export const Vector3 = struct('Vector3', { x: SinglePrecisionFloat, … });
+ * export type Vector3 = Struct<typeof Vector3>;
+ * ```
+ *
+ * @template TDescriptor Type of the descriptor `struct` returned.
+ */
+export type Struct<TDescriptor extends StructType<StructFields>> = TDescriptor extends StructType<infer TFields> ? StructValue<TFields> : never;
+/**
+ * Declares a struct: a value type with a fixed layout.
+ *
+ * ```ts
+ * export const Vector3 = struct('Vector3', {
+ * 	x: SinglePrecisionFloat,
+ * 	y: SinglePrecisionFloat,
+ * 	z: SinglePrecisionFloat,
+ * });
+ * export type Vector3 = Struct<typeof Vector3>;
+ *
+ * const up: Vector3 = Vector3.from({ x: 0, y: 1, z: 0 });
+ *
+ * Vector3.layout.size; // 12
+ * Vector3.write(new DataView(buffer), 0, up);
+ * ```
+ *
+ * A value has no identity: it is frozen, two values with the same fields are
+ * equal by {@link StructType.equals}, and it can be written into bytes and
+ * read back as the same value. It is still a JavaScript object while it is
+ * held as one; the layout is what it occupies when it is stored.
+ *
+ * @param name Name of the struct, for error messages.
+ * @param fields Descriptor of each field, by name.
+ * @returns The descriptor of the struct.
+ * @throws {TypeError} When there is no field, a field's type has no fixed
+ * layout, or a field is named like an array index or `~layout`.
+ */
+export declare const struct: <TFields extends StructFields>(name: string, fields: TFields) => StructType<TFields>;
+export {};

package/dist/struct/index.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.struct = void 0;
+const codec_1 = require("./codec.js");
+/**
+ * Keys an object lists before every other, in numeric order, whatever order
+ * they were written in. A field named like one would silently move, so it is
+ * refused.
+ */
+const ARRAY_INDEX = /^(?:0|[1-9]\d*)$/;
+/**
+ * Describes a value for an error message.
+ *
+ * @param value Value being reported.
+ * @returns Its kind.
+ */
+const describeKind = (value) => value === null ? 'null' : typeof value;
+/**
+ * Re-throws the error a field's own conversion raised, naming the field.
+ *
+ * @param name Name of the struct.
+ * @param key Field being converted.
+ * @param error What the conversion threw.
+ * @returns Never.
+ */
+const rethrowForField = (name, key, error) => {
+    const message = (original) => `${name}.from: field '${key}': ${original.message}`;
+    if (error instanceof RangeError) {
+        throw new RangeError(message(error), { cause: error });
+    }
+    if (error instanceof TypeError) {
+        throw new TypeError(message(error), { cause: error });
+    }
+    if (error instanceof SyntaxError) {
+        throw new SyntaxError(message(error), { cause: error });
+    }
+    throw error;
+};
+/**
+ * Declares a struct: a value type with a fixed layout.
+ *
+ * ```ts
+ * export const Vector3 = struct('Vector3', {
+ * 	x: SinglePrecisionFloat,
+ * 	y: SinglePrecisionFloat,
+ * 	z: SinglePrecisionFloat,
+ * });
+ * export type Vector3 = Struct<typeof Vector3>;
+ *
+ * const up: Vector3 = Vector3.from({ x: 0, y: 1, z: 0 });
+ *
+ * Vector3.layout.size; // 12
+ * Vector3.write(new DataView(buffer), 0, up);
+ * ```
+ *
+ * A value has no identity: it is frozen, two values with the same fields are
+ * equal by {@link StructType.equals}, and it can be written into bytes and
+ * read back as the same value. It is still a JavaScript object while it is
+ * held as one; the layout is what it occupies when it is stored.
+ *
+ * @param name Name of the struct, for error messages.
+ * @param fields Descriptor of each field, by name.
+ * @returns The descriptor of the struct.
+ * @throws {TypeError} When there is no field, a field's type has no fixed
+ * layout, or a field is named like an array index or `~layout`.
+ */
+const struct = (name, fields) => {
+    if (typeof name !== 'string' || name === '') {
+        throw new TypeError(`struct: expected a name, received ${describeKind(name)}.`);
+    }
+    if (typeof fields !== 'object' || fields === null) {
+        throw new TypeError(`struct ${name}: expected an object of fields, received ${describeKind(fields)}.`);
+    }
+    const keys = Object.keys(fields);
+    if (keys.length === 0) {
+        throw new TypeError(`struct ${name}: expected at least one field.`);
+    }
+    const declared = keys.map((key) => {
+        if (ARRAY_INDEX.test(key) || key === '~layout') {
+            throw new TypeError(`struct ${name}: '${key}' cannot name a field; an array index would be reordered, and '~layout' is the layout itself.`);
+        }
+        const codec = (0, codec_1.codecOf)(fields[key]);
+        if (codec === undefined) {
+            throw new TypeError(`struct ${name}: field '${key}' has no fixed layout. Declare it with a numeric type of @fulcro/types other than BigInteger, or with another struct.`);
+        }
+        return { key, descriptor: fields[key], codec };
+    });
+    // Largest alignment first, so that every field lands aligned without padding
+    // before it: each size is a multiple of its own alignment. `sort` is stable,
+    // which keeps declaration order among equals.
+    const offsets = new Map();
+    let end = 0;
+    for (const field of [...declared].sort((left, right) => right.codec.alignment - left.codec.alignment)) {
+        offsets.set(field.key, end);
+        end += field.codec.size;
+    }
+    const alignment = Math.max(...declared.map((field) => field.codec.alignment));
+    const size = Math.ceil(end / alignment) * alignment;
+    const plan = declared.map((field) => ({
+        ...field,
+        descriptor: field.descriptor,
+        offset: offsets.get(field.key),
+    }));
+    const layout = Object.freeze({
+        size,
+        alignment,
+        fields: Object.freeze(Object.fromEntries(plan.map((field) => [
+            field.key,
+            Object.freeze({
+                offset: field.offset,
+                size: field.codec.size,
+                alignment: field.codec.alignment,
+            }),
+        ]))),
+    });
+    /**
+     * Refuses a view and an offset the struct does not fit in, before a byte is
+     * touched — so a failed write leaves the view as it was.
+     *
+     * @param operation Operation being performed.
+     * @param view View handed in.
+     * @param offset Offset handed in.
+     */
+    const requireRoom = (operation, view, offset) => {
+        if (!(view instanceof DataView)) {
+            throw new TypeError(`${name}.${operation}: expected a DataView, received ${describeKind(view)}.`);
+        }
+        if (!Number.isInteger(offset) ||
+            offset < 0 ||
+            offset + size > view.byteLength) {
+            throw new RangeError(`${name}.${operation}: ${size} bytes at offset ${offset} do not fit in a view of ${view.byteLength} bytes.`);
+        }
+    };
+    const readFields = (view, offset) => {
+        const value = {};
+        for (const field of plan) {
+            value[field.key] = field.codec.read(view, offset + field.offset);
+        }
+        return Object.freeze(value);
+    };
+    const writeFields = (view, offset, value) => {
+        for (const field of plan) {
+            field.codec.write(view, offset + field.offset, value[field.key]);
+        }
+    };
+    const equals = (left, right) => plan.every((field) => field.codec.equals(left[field.key], right[field.key]));
+    const descriptor = {
+        name,
+        layout: layout,
+        from: (source) => {
+            if (typeof source !== 'object' || source === null) {
+                throw new TypeError(`${name}.from: expected an object, received ${describeKind(source)}.`);
+            }
+            for (const key of Object.keys(source)) {
+                if (!Object.hasOwn(fields, key)) {
+                    throw new TypeError(`${name}.from: '${key}' is not a field; the fields are ${keys.join(', ')}.`);
+                }
+            }
+            const value = {};
+            for (const field of plan) {
+                if (!Object.hasOwn(source, field.key)) {
+                    throw new TypeError(`${name}.from: missing field '${field.key}'.`);
+                }
+                try {
+                    value[field.key] = field.descriptor.from(source[field.key]);
+                }
+                catch (error) {
+                    rethrowForField(name, field.key, error);
+                }
+            }
+            return Object.freeze(value);
+        },
+        is: (value) => typeof value === 'object' &&
+            value !== null &&
+            Object.isFrozen(value) &&
+            Object.keys(value).length === plan.length &&
+            plan.every((field) => Object.hasOwn(value, field.key) &&
+                field.descriptor.is(value[field.key])),
+        equals,
+        read: (view, offset) => {
+            requireRoom('read', view, offset);
+            return readFields(view, offset);
+        },
+        write: (view, offset, value) => {
+            requireRoom('write', view, offset);
+            writeFields(view, offset, value);
+        },
+    };
+    (0, codec_1.registerStructCodec)(descriptor, {
+        size,
+        alignment,
+        read: readFields,
+        write: writeFields,
+        equals,
+    });
+    return descriptor;
+};
+exports.struct = struct;

package/package.json

@@ -1,71 +1,71 @@
-{
-	"name": "@fulcro/types",
-	"version": "0.1.0",
-	"description": "Numeric types with a defined range and layout: fixed-width integers, half, single and double precision floats, and a decimal128 Decimal.",
-	"keywords": [
-		"integer",
-		"float",
-		"decimal",
-		"decimal128",
-		"numeric",
-		"typescript"
-	],
-	"license": "ISC",
-	"author": "diguu <rodrigogeribola@hotmail.com>",
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"default": "./dist/index.js"
-		},
-		"./transformer": {
-			"types": "./dist/transformer/index.d.ts",
-			"default": "./dist/transformer/index.js"
-		},
-		"./unplugin": {
-			"types": "./dist/unplugin/index.d.mts",
-			"default": "./dist/unplugin/index.mjs"
-		},
-		"./language-service": {
-			"types": "./dist/languageService/index.d.ts",
-			"default": "./dist/languageService/index.js"
-		},
-		"./package.json": "./package.json"
-	},
-	"files": [
-		"dist"
-	],
-	"sideEffects": false,
-	"dependencies": {
-		"@fulcro/transform-core": "^0.10.0"
-	},
-	"peerDependencies": {
-		"typescript": ">=5.3.3 <7"
-	},
-	"peerDependenciesMeta": {
-		"typescript": {
-			"optional": true
-		}
-	},
-	"engines": {
-		"node": ">=22"
-	},
-	"publishConfig": {
-		"access": "public"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/DigUu-RL/fulcro.git",
-		"directory": "packages/types"
-	},
-	"homepage": "https://github.com/DigUu-RL/fulcro/tree/main/packages/types#readme",
-	"bugs": {
-		"url": "https://github.com/DigUu-RL/fulcro/issues"
-	},
-	"scripts": {
-		"build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-		"typecheck": "tsc --noEmit -p tsconfig.json",
-		"prepublishOnly": "npm run build"
-	}
-}
+{
+	"name": "@fulcro/types",
+	"version": "0.2.0",
+	"description": "Numeric types with a defined range and layout: fixed-width integers, half, single and double precision floats, and a decimal128 Decimal.",
+	"keywords": [
+		"integer",
+		"float",
+		"decimal",
+		"decimal128",
+		"numeric",
+		"typescript"
+	],
+	"license": "ISC",
+	"author": "diguu <rodrigogeribola@hotmail.com>",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./transformer": {
+			"types": "./dist/transformer/index.d.ts",
+			"default": "./dist/transformer/index.js"
+		},
+		"./unplugin": {
+			"types": "./dist/unplugin/index.d.mts",
+			"default": "./dist/unplugin/index.mjs"
+		},
+		"./language-service": {
+			"types": "./dist/languageService/index.d.ts",
+			"default": "./dist/languageService/index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"files": [
+		"dist"
+	],
+	"sideEffects": false,
+	"dependencies": {
+		"@fulcro/transform-core": "^0.10.0"
+	},
+	"peerDependencies": {
+		"typescript": ">=5.3.3 <7"
+	},
+	"peerDependenciesMeta": {
+		"typescript": {
+			"optional": true
+		}
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/DigUu-RL/fulcro.git",
+		"directory": "packages/types"
+	},
+	"homepage": "https://github.com/DigUu-RL/fulcro/tree/main/packages/types#readme",
+	"bugs": {
+		"url": "https://github.com/DigUu-RL/fulcro/issues"
+	},
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+		"typecheck": "tsc --noEmit -p tsconfig.json",
+		"prepublishOnly": "npm run build"
+	}
+}