@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/core/src/sab/gamepad-devices.js

@@ -0,0 +1,205 @@
+// ============================================================================
+// Gamepad Devices Buffer — per-device gamepad metadata + state
+// Writer: the native downdraft_gamepad cdylib worker thread (Rust) writes every
+//   field EXCEPT `hostMeta`, which is owned by JS sysfs/enrichment code.
+// Readers: renderer/main thread (device discovery, nav, enrichment output).
+//
+// This channel is a *device table* — identity, connection, battery, name — and
+// a raw-state mirror. Per-player routed input lives in MultiInputChannel.
+// ============================================================================
+import { defineChannel } from "./define.js";
+export const GAMEPAD_DEVICES_MAGIC = 0x50474444; // "DDGP"
+export const GAMEPAD_DEVICES_VERSION = 1;
+export const GAMEPAD_MAX_SLOTS = 16;
+/** Pad classification written by the native backend (mirrors Rust pad_type). */
+export const PadType = {
+    UNKNOWN: 0,
+    XBOX: 1,
+    PS3: 2,
+    PS4: 3,
+    PS5: 4,
+    SWITCH: 5,
+    GAMECUBE: 6,
+    N64: 7,
+    WIIMOTE: 8,
+    STEAM: 9,
+    GENERIC: 10,
+};
+/** Connection classification (mirrors Rust conn_type). */
+export const PadConnType = {
+    UNKNOWN: 0,
+    WIRED: 1,
+    BLUETOOTH: 2,
+    DONGLE: 3,
+};
+/** meta1 flag bits. */
+export const PAD_FLAG = {
+    FF_SUPPORTED: 1 << 0,
+    CHARGING: 1 << 1,
+    AUX_DEVICE: 1 << 2,
+};
+/** Battery sentinels (meta0 >> 24). */
+export const PAD_BATTERY_UNKNOWN = 255;
+export const PAD_BATTERY_WIRED = 254;
+/** Standard-layout button bitmask (buttonsLo; buttonsHi is reserved for
+ *  touchpad/paddle/misc). Bit indices match W3C standard mapping order. */
+export const GP_BTN = {
+    SOUTH: 0,
+    EAST: 1,
+    WEST: 2,
+    NORTH: 3,
+    LEFT_SHOULDER: 4,
+    RIGHT_SHOULDER: 5,
+    LEFT_TRIGGER_BTN: 6,
+    RIGHT_TRIGGER_BTN: 7,
+    SELECT: 8,
+    START: 9,
+    HOME: 10,
+    LEFT_STICK: 11,
+    RIGHT_STICK: 12,
+    DPAD_UP: 13,
+    DPAD_DOWN: 14,
+    DPAD_LEFT: 15,
+    DPAD_RIGHT: 16,
+    C: 17,
+    Z: 18,
+    CAPTURE: 19,
+};
+/** Axis indices in axes[8]. */
+export const GP_AXIS = {
+    LEFT_X: 0,
+    LEFT_Y: 1,
+    RIGHT_X: 2,
+    RIGHT_Y: 3,
+    LEFT_TRIGGER: 4,
+    RIGHT_TRIGGER: 5,
+    DPAD_X: 6,
+    DPAD_Y: 7,
+};
+export const GamepadDevicesChannel = defineChannel({
+    name: "gamepad-devices",
+    magic: GAMEPAD_DEVICES_MAGIC,
+    version: GAMEPAD_DEVICES_VERSION,
+    mode: "slots",
+    header: {
+        size: 64,
+        fields: {
+            connectedMask: { type: "u32" },
+        },
+    },
+    sections: [
+        {
+            name: "pads",
+            maxSlots: GAMEPAD_MAX_SLOTS,
+            slotSize: 128,
+            // Field order is the ABI — must stay in sync with
+            // packages/platform-native/native-gamepad/src/lib.rs SLOT_* offsets.
+            fields: {
+                meta0: { type: "u32" }, // connected | padType<<8 | connType<<16 | battery<<24
+                meta1: { type: "u32" }, // PAD_FLAG_*
+                hostMeta: { type: "u32" }, // rssi | jsFlags<<8 | reserved — JS writes this
+                buttonsLo: { type: "u32" },
+                buttonsHi: { type: "u32" },
+                axes: { type: "f32", count: 8 },
+                lastEventMs: { type: "u32" },
+                slotSeq: { type: "u32" },
+                vendorId: { type: "u32" },
+                productId: { type: "u32" },
+                name: { type: "u32", count: 14 }, // 56 B NUL-padded UTF-8
+                aux: { type: "u32" }, // Linux: /dev/input/eventN index; 0xFFFF unknown
+            },
+        },
+    ],
+});
+const textDecoder = new TextDecoder();
+/**
+ * Reader for the device table. Construct per-thread over the shared buffer;
+ * call `readSlot`/`readConnected` from the consuming side only.
+ */
+export class GamepadDevicesReader {
+    reader;
+    pads;
+    constructor(sab) {
+        this.reader = GamepadDevicesChannel.reader(sab);
+        this.pads = this.reader.sections.pads;
+    }
+    isValid() {
+        return this.reader.isValid();
+    }
+    validationError() {
+        return this.reader.validationError();
+    }
+    getSequence() {
+        return this.reader.getSequence();
+    }
+    hasChanged(lastSeen) {
+        return this.reader.hasChanged(lastSeen);
+    }
+    getConnectedMask() {
+        return this.reader.header.u32[GamepadDevicesChannel.offsets.header.connectedMask];
+    }
+    slotViews(slot) {
+        return this.pads.slot(slot);
+    }
+    readSlot(slot, out) {
+        const f = GamepadDevicesChannel.offsets.sections.pads.fields;
+        const sv = this.slotViews(slot);
+        const meta0 = sv.u32[f.meta0];
+        if ((meta0 & 0xff) === 0)
+            return null;
+        const axes = out?.axes ?? new Float32Array(8);
+        axes.set(sv.f32.subarray(f.axes, f.axes + 8));
+        // Decode the 56-byte NUL-padded name. Reinterpret the slot u32 region.
+        const nameBytes = new Uint8Array(sv.u32.buffer, sv.u32.byteOffset + f.name * 4, 56);
+        let nameLen = nameBytes.indexOf(0);
+        if (nameLen < 0)
+            nameLen = 56;
+        return {
+            slot,
+            connected: true,
+            padType: ((meta0 >>> 8) & 0xff),
+            connType: ((meta0 >>> 16) & 0xff),
+            battery: (meta0 >>> 24) & 0xff,
+            rssi: sv.u32[f.hostMeta] & 0xff,
+            flags: sv.u32[f.meta1],
+            buttonsLo: sv.u32[f.buttonsLo],
+            buttonsHi: sv.u32[f.buttonsHi],
+            axes,
+            lastEventMs: sv.u32[f.lastEventMs],
+            slotSeq: sv.u32[f.slotSeq],
+            vendorId: sv.u32[f.vendorId],
+            productId: sv.u32[f.productId],
+            name: textDecoder.decode(nameBytes.subarray(0, nameLen)),
+            eventNode: (sv.u32[f.aux] & 0xffff) === 0xffff ? -1 : sv.u32[f.aux] & 0xffff,
+        };
+    }
+    /** Iterate all currently-connected slots. Allocates one object per pad —
+     *  fine for UI/discovery at event cadence; for per-frame input read
+     *  axes/buttons directly via `rawSlot`. */
+    *readConnected() {
+        const mask = this.getConnectedMask();
+        for (let i = 0; i < GAMEPAD_MAX_SLOTS; i++) {
+            if (mask & (1 << i)) {
+                const d = this.readSlot(i);
+                if (d)
+                    yield d;
+            }
+        }
+    }
+}
+/**
+ * Writer for the JS-owned enrichment field (`hostMeta`). Only JS sysfs
+ * enrichment should construct this — the native worker owns everything else.
+ */
+export class GamepadDevicesHostMetaWriter {
+    pads;
+    constructor(sab) {
+        this.pads = GamepadDevicesChannel.writer(sab).sections.pads;
+    }
+    /** Write RSSI (0..100, 255 unknown) + JS flag byte for a slot. */
+    setHostMeta(slot, rssi, jsFlags = 0) {
+        const f = GamepadDevicesChannel.offsets.sections.pads.fields;
+        const sv = this.pads.slot(slot);
+        sv.u32[f.hostMeta] = ((rssi & 0xff) | ((jsFlags & 0xff) << 8)) >>> 0;
+    }
+}

package/dist/core/src/sab/grid-buffer.js

@@ -0,0 +1,91 @@
+import { describeHeaderValidation } from "./errors.js";
+function createHeaderViews(sab, headerSize) {
+    const u32Length = headerSize / 4;
+    return {
+        u32: new Uint32Array(sab, 0, u32Length),
+        i32: new Int32Array(sab, 0, u32Length),
+        f32: new Float32Array(sab, 0, u32Length),
+        f64: new Float64Array(sab, 0, Math.floor(headerSize / 8)),
+    };
+}
+function createLayerView(sab, layer) {
+    switch (layer.type) {
+        case "f32": return new Float32Array(sab, layer.byteOffset, layer.length);
+        case "i32": return new Int32Array(sab, layer.byteOffset, layer.length);
+        case "u32": return new Uint32Array(sab, layer.byteOffset, layer.length);
+        case "bool": return new Uint32Array(sab, layer.byteOffset, layer.length);
+        case "f64": return new Float64Array(sab, layer.byteOffset, layer.length);
+        default: return new Float32Array(sab, layer.byteOffset, layer.length);
+    }
+}
+export class GridReader {
+    header;
+    layers;
+    seqArr;
+    layout;
+    constructor(sab, layout) {
+        this.layout = layout;
+        this.header = createHeaderViews(sab, layout.header.size);
+        this.seqArr = new Int32Array(sab, layout.header.sequenceIndex * 4, 1);
+        this.layers = {};
+        if (layout.grid) {
+            for (const [name, layer] of Object.entries(layout.grid.layers)) {
+                this.layers[name] = createLayerView(sab, layer);
+            }
+        }
+    }
+    isValid() {
+        return this.validationError() === null;
+    }
+    validationError() {
+        return describeHeaderValidation(this.header.u32, this.layout.header.magicIndex, this.layout.header.versionIndex, this.layout.magic, this.layout.version);
+    }
+    getSequence() {
+        return Atomics.load(this.seqArr, 0);
+    }
+    hasChanged(lastSeen) {
+        return this.getSequence() !== lastSeen;
+    }
+    snapshot() {
+        const data = {};
+        data["sequence"] = this.getSequence();
+        if (this.layout.grid) {
+            for (const [name, layer] of Object.entries(this.layout.grid.layers)) {
+                const view = this.layers[name];
+                const copy = [];
+                for (let i = 0; i < layer.length; i++) {
+                    copy.push(view[i]);
+                }
+                data[name] = copy;
+            }
+        }
+        return data;
+    }
+}
+export class GridWriter {
+    header;
+    layers;
+    seqArr;
+    layout;
+    constructor(sab, layout) {
+        this.layout = layout;
+        this.header = createHeaderViews(sab, layout.header.size);
+        this.seqArr = new Int32Array(sab, layout.header.sequenceIndex * 4, 1);
+        this.layers = {};
+        if (layout.grid) {
+            for (const [name, layer] of Object.entries(layout.grid.layers)) {
+                this.layers[name] = createLayerView(sab, layer);
+            }
+        }
+    }
+    init() {
+        this.header.u32[this.layout.header.magicIndex] = this.layout.magic;
+        this.header.u32[this.layout.header.versionIndex] = this.layout.version;
+    }
+    bumpSequence() {
+        Atomics.add(this.seqArr, 0, 1);
+    }
+    getSequence() {
+        return Atomics.load(this.seqArr, 0);
+    }
+}

package/dist/core/src/sab/input.js

@@ -0,0 +1,38 @@
+import { CoreInputChannel } from "./core-input-channel.js";
+export class InputSABChannel {
+    writer;
+    sab;
+    constructor(sab) {
+        this.sab = sab ?? CoreInputChannel.allocate();
+        this.writer = CoreInputChannel.writer(this.sab);
+    }
+    getBuffer() {
+        return this.sab;
+    }
+    write(keys, mouseX, mouseY, mouseDeltaX, mouseDeltaY, mouseButtons, wheelDelta, gamepadButtons, gamepadAxes) {
+        const w = this.writer;
+        for (let i = 0; i < 8; i++) {
+            w.fields.keys[i] = i < keys.length ? keys[i] : 0;
+        }
+        w.fields.mouseX[0] = mouseX;
+        w.fields.mouseY[0] = mouseY;
+        w.fields.mouseDeltaX[0] = mouseDeltaX;
+        w.fields.mouseDeltaY[0] = mouseDeltaY;
+        for (let i = 0; i < 3; i++) {
+            w.fields.mouseButtons[i] = i < mouseButtons.length ? mouseButtons[i] : 0;
+        }
+        w.fields.wheelDelta[0] = wheelDelta;
+        // gamepadButtons is the bitmask pair [lo, hi] — W3C standard order.
+        const gp = w.fields.gamepadButtons;
+        gp[0] = (gamepadButtons[0] ?? 0) >>> 0;
+        gp[1] = (gamepadButtons[1] ?? 0) >>> 0;
+        for (let i = 0; i < 8; i++) {
+            w.fields.gamepadAxes[i] = i < gamepadAxes.length ? gamepadAxes[i] : 0;
+        }
+        w.bumpSequence();
+    }
+    read() {
+        const reader = CoreInputChannel.reader(this.sab);
+        return reader.snapshot();
+    }
+}

package/dist/core/src/sab/layout.js

@@ -0,0 +1,160 @@
+import { alignUp, typeSize, ValidationError } from "./errors.js";
+const HEADER_MAGIC_INDEX = 0;
+const HEADER_VERSION_INDEX = 1;
+const HEADER_SEQUENCE_INDEX = 2;
+const HEADER_RESERVED_END = 3;
+function computeFieldLayout(name, def, byteOffset) {
+    const size = typeSize(def.type);
+    const count = def.count ?? 1;
+    const aligned = alignUp(byteOffset, size);
+    const totalBytes = size * count;
+    return {
+        layout: {
+            name,
+            type: def.type,
+            count,
+            atomic: def.atomic ?? false,
+            byteOffset: aligned,
+            index: aligned / 4,
+        },
+        nextOffset: aligned + totalBytes,
+    };
+}
+function computeFieldMap(fields, startOffset) {
+    const layouts = {};
+    let offset = startOffset;
+    for (const [name, def] of Object.entries(fields)) {
+        const { layout, nextOffset } = computeFieldLayout(name, def, offset);
+        layouts[name] = layout;
+        offset = nextOffset;
+    }
+    return { layouts, endOffset: offset };
+}
+function computeHeaderLayout(header) {
+    const fields = {};
+    fields["magic"] = {
+        name: "magic",
+        type: "u32",
+        count: 1,
+        atomic: false,
+        byteOffset: HEADER_MAGIC_INDEX * 4,
+        index: HEADER_MAGIC_INDEX,
+    };
+    fields["version"] = {
+        name: "version",
+        type: "u32",
+        count: 1,
+        atomic: false,
+        byteOffset: HEADER_VERSION_INDEX * 4,
+        index: HEADER_VERSION_INDEX,
+    };
+    fields["sequence"] = {
+        name: "sequence",
+        type: "u32",
+        count: 1,
+        atomic: true,
+        byteOffset: HEADER_SEQUENCE_INDEX * 4,
+        index: HEADER_SEQUENCE_INDEX,
+    };
+    const userStart = HEADER_RESERVED_END * 4;
+    const { layouts, endOffset } = computeFieldMap(header.fields, userStart);
+    Object.assign(fields, layouts);
+    if (endOffset > header.size) {
+        throw new ValidationError(`Header fields overflow: need ${endOffset} bytes but header size is ${header.size}`);
+    }
+    return {
+        size: header.size,
+        fields,
+        magicIndex: HEADER_MAGIC_INDEX,
+        versionIndex: HEADER_VERSION_INDEX,
+        sequenceIndex: HEADER_SEQUENCE_INDEX,
+    };
+}
+function computeSlotSectionLayouts(sections, headerSize) {
+    const layouts = [];
+    let offset = headerSize;
+    sections.forEach((section) => {
+        const { layouts: fieldLayouts, endOffset: fieldsEnd } = computeFieldMap(section.fields, 0);
+        if (fieldsEnd > section.slotSize) {
+            throw new ValidationError(`Slot section "${section.name}" fields overflow: need ${fieldsEnd} bytes but slot size is ${section.slotSize}`);
+        }
+        const sectionByteOffset = offset;
+        const slotStride = section.slotSize / 4;
+        layouts.push({
+            name: section.name,
+            maxSlots: section.maxSlots,
+            slotSize: section.slotSize,
+            byteOffset: sectionByteOffset,
+            slotStride,
+            fields: fieldLayouts,
+        });
+        offset += section.maxSlots * section.slotSize;
+    });
+    return { layouts, endOffset: offset };
+}
+function computeGridLayout(grid, headerSize) {
+    const layers = {};
+    let offset = headerSize;
+    const gridSize = grid.size;
+    for (const [name, layer] of Object.entries(grid.layers)) {
+        const size = typeSize(layer.type);
+        const aligned = alignUp(offset, size);
+        const elementCount = gridSize * gridSize * layer.components;
+        const totalBytes = size * elementCount;
+        layers[name] = {
+            name,
+            type: layer.type,
+            components: layer.components,
+            byteOffset: aligned,
+            length: elementCount,
+        };
+        offset = aligned + totalBytes;
+    }
+    return { size: gridSize, layers, endOffset: offset };
+}
+export function computeLayout(def) {
+    const header = computeHeaderLayout(def.header);
+    if (def.mode === "record") {
+        if (!def.fields) {
+            throw new ValidationError(`Channel "${def.name}" in record mode requires "fields"`);
+        }
+        const { layouts, endOffset } = computeFieldMap(def.fields, header.size);
+        return {
+            byteLength: endOffset,
+            mode: "record",
+            magic: def.magic,
+            version: def.version,
+            header,
+            fields: layouts,
+        };
+    }
+    if (def.mode === "slots") {
+        if (!def.sections || def.sections.length === 0) {
+            throw new ValidationError(`Channel "${def.name}" in slots mode requires "sections"`);
+        }
+        const { layouts, endOffset } = computeSlotSectionLayouts(def.sections, header.size);
+        return {
+            byteLength: endOffset,
+            mode: "slots",
+            magic: def.magic,
+            version: def.version,
+            header,
+            sections: layouts,
+        };
+    }
+    if (def.mode === "grid") {
+        if (!def.grid) {
+            throw new ValidationError(`Channel "${def.name}" in grid mode requires "grid"`);
+        }
+        const { size, layers, endOffset } = computeGridLayout(def.grid, header.size);
+        return {
+            byteLength: endOffset,
+            mode: "grid",
+            magic: def.magic,
+            version: def.version,
+            header,
+            grid: { size, layers },
+        };
+    }
+    throw new ValidationError(`Unknown channel mode: "${def.mode}"`);
+}

package/dist/core/src/sab/multi-input-channel.js

@@ -0,0 +1,39 @@
+import { defineChannel } from "./define.js";
+export function createMultiInputChannel(opts = {}) {
+    const maxPlayers = opts.maxPlayers ?? 8;
+    const keyCount = opts.keyBitfieldCount ?? 8;
+    return defineChannel({
+        name: "multi-input",
+        magic: 0x4d495043,
+        // v2: gamepadButtons is now a u32 bitmask pair ([lo, hi], W3C standard
+        // button order = GP_BTN_* in ./gamepad-devices.ts), gamepadAxes grows to
+        // 8 (lx ly rx ry lt rt dpadX dpadY), and gamepadSlot binds the player to
+        // a device-table slot in the 'gamepad-devices' channel (0xFF = none).
+        version: 2,
+        mode: "slots",
+        header: { size: 64, fields: {} },
+        sections: [
+            {
+                name: "players",
+                maxSlots: maxPlayers,
+                slotSize: 256,
+                fields: {
+                    keys: { type: "i32", count: keyCount },
+                    mouseX: { type: "f32" },
+                    mouseY: { type: "f32" },
+                    mouseDeltaX: { type: "f32" },
+                    mouseDeltaY: { type: "f32" },
+                    mouseButtons: { type: "i32", count: 3 },
+                    wheelDelta: { type: "f32" },
+                    gamepadButtons: { type: "u32", count: 2 },
+                    gamepadAxes: { type: "f32", count: 8 },
+                    gamepadSlot: { type: "u32" },
+                    flags: { type: "u32" },
+                },
+            },
+        ],
+    });
+}
+export const DEFAULT_MAX_PLAYERS = 8;
+export const DEFAULT_KEY_BITFIELD_COUNT = 8;
+export const MultiInputChannel = createMultiInputChannel();

package/dist/core/src/sab/record-buffer.js

@@ -0,0 +1,130 @@
+import { describeHeaderValidation, isDebug, warnOnce } from "./errors.js";
+function createHeaderViews(sab, headerSize) {
+    const u32Length = headerSize / 4;
+    return {
+        u32: new Uint32Array(sab, 0, u32Length),
+        i32: new Int32Array(sab, 0, u32Length),
+        f32: new Float32Array(sab, 0, u32Length),
+        f64: new Float64Array(sab, 0, Math.floor(headerSize / 8)),
+    };
+}
+function createFieldView(sab, field) {
+    switch (field.type) {
+        case "f32": return new Float32Array(sab, field.byteOffset, field.count);
+        case "i32": return new Int32Array(sab, field.byteOffset, field.count);
+        case "u32": return new Uint32Array(sab, field.byteOffset, field.count);
+        case "bool": return new Int32Array(sab, field.byteOffset, field.count);
+        case "f64": return new Float64Array(sab, field.byteOffset, field.count);
+        default: return new Float32Array(sab, field.byteOffset, field.count);
+    }
+}
+export class RecordReader {
+    header;
+    fields;
+    seqArr;
+    layout;
+    lastSnapshot = null;
+    constructor(sab, layout) {
+        this.layout = layout;
+        this.header = createHeaderViews(sab, layout.header.size);
+        this.seqArr = new Int32Array(sab, layout.header.sequenceIndex * 4, 1);
+        this.fields = {};
+        if (layout.fields) {
+            for (const [name, field] of Object.entries(layout.fields)) {
+                this.fields[name] = createFieldView(sab, field);
+            }
+        }
+    }
+    isValid() {
+        return this.validationError() === null;
+    }
+    validationError() {
+        return describeHeaderValidation(this.header.u32, this.layout.header.magicIndex, this.layout.header.versionIndex, this.layout.magic, this.layout.version);
+    }
+    getSequence() {
+        return Atomics.load(this.seqArr, 0);
+    }
+    hasChanged(lastSeen) {
+        return this.getSequence() !== lastSeen;
+    }
+    snapshot() {
+        const data = {};
+        if (this.layout.fields) {
+            for (const [name, field] of Object.entries(this.layout.fields)) {
+                const view = this.fields[name];
+                if (field.count === 1) {
+                    data[name] = view[0];
+                }
+                else {
+                    const copy = [];
+                    for (let i = 0; i < field.count; i++) {
+                        copy.push(view[i]);
+                    }
+                    data[name] = copy;
+                }
+            }
+        }
+        this.lastSnapshot = data;
+        return data;
+    }
+}
+export class RecordWriter {
+    header;
+    fields;
+    seqArr;
+    layout;
+    constructor(sab, layout) {
+        this.layout = layout;
+        this.header = createHeaderViews(sab, layout.header.size);
+        this.seqArr = new Int32Array(sab, layout.header.sequenceIndex * 4, 1);
+        this.fields = {};
+        if (layout.fields) {
+            for (const [name, field] of Object.entries(layout.fields)) {
+                this.fields[name] = createFieldView(sab, field);
+            }
+        }
+    }
+    init() {
+        this.header.u32[this.layout.header.magicIndex] = this.layout.magic;
+        this.header.u32[this.layout.header.versionIndex] = this.layout.version;
+    }
+    beginWrite() {
+        const seq = Atomics.load(this.seqArr, 0);
+        Atomics.store(this.seqArr, 0, seq + 1);
+    }
+    endWrite() {
+        // Sequence is incremented in beginWrite() — endWrite() is a no-op
+        // to avoid double incrementing.
+    }
+    bumpSequence() {
+        Atomics.add(this.seqArr, 0, 1);
+    }
+    getSequence() {
+        return Atomics.load(this.seqArr, 0);
+    }
+    write(data) {
+        this.beginWrite();
+        if (this.layout.fields) {
+            for (const [name, value] of Object.entries(data)) {
+                const view = this.fields[name];
+                if (!view) {
+                    if (isDebug())
+                        warnOnce(`record-write-unknown-${name}`, `Unknown field "${name}" in write()`);
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    for (let i = 0; i < value.length && i < view.length; i++) {
+                        view[i] = value[i];
+                    }
+                }
+                else if (typeof value === "number") {
+                    view[0] = value;
+                }
+                else if (typeof value === "boolean") {
+                    view[0] = value ? 1 : 0;
+                }
+            }
+        }
+        this.endWrite();
+    }
+}