@antines/protocol 0.1.0

package/dist/header.d.ts

@@ -0,0 +1,18 @@
+import { Direction, MessageType, type Header } from "./types.js";
+/**
+ * Encode a Header into a 32-byte buffer.
+ */
+export declare function encodeHeader(h: Header): ArrayBuffer;
+/**
+ * Decode a 32-byte buffer into a Header.
+ */
+export declare function decodeHeader(buf: ArrayBuffer): Header;
+/**
+ * Read a header from an ArrayBuffer-like source.
+ */
+export declare function readHeader(buffer: ArrayBuffer): Header;
+/**
+ * Create a new Header with sensible defaults.
+ */
+export declare function newHeader(direction: Direction, msgType: MessageType, requestId: number, handlerId: number, statusCode: number, payloadLen: number): Header;
+//# sourceMappingURL=header.d.ts.map

package/dist/header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../src/header.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAsB,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAErF;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAgBnD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,MAAM,CAwBrD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAEtD;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,MAAM,CAaR"}

package/dist/header.js

@@ -0,0 +1,67 @@
+import { Direction, MessageType, MAGIC, HEADER_SIZE } from "./types.js";
+/**
+ * Encode a Header into a 32-byte buffer.
+ */
+export function encodeHeader(h) {
+    const buf = new ArrayBuffer(HEADER_SIZE);
+    const dv = new DataView(buf);
+    dv.setUint32(0, h.magic, true); // offset 0: magic
+    dv.setUint8(4, h.version); // offset 4: version
+    dv.setUint8(5, h.direction); // offset 5: direction
+    dv.setUint8(6, h.msgType); // offset 6: msgType
+    dv.setUint8(7, h.flags); // offset 7: flags
+    dv.setUint32(8, h.requestId, true); // offset 8: requestId
+    dv.setUint32(12, h.handlerId, true); // offset 12: handlerId
+    dv.setUint32(16, h.payloadLen, true); // offset 16: payloadLen
+    dv.setUint32(20, h.statusCode, true); // offset 20: statusCode
+    // offset 24-31: reserved (zeros)
+    return buf;
+}
+/**
+ * Decode a 32-byte buffer into a Header.
+ */
+export function decodeHeader(buf) {
+    if (buf.byteLength < HEADER_SIZE) {
+        throw new Error(`Header too small: ${buf.byteLength} bytes`);
+    }
+    const dv = new DataView(buf);
+    const magic = dv.getUint32(0, true);
+    if (magic !== MAGIC) {
+        throw new Error(`Invalid magic: 0x${magic.toString(16)}`);
+    }
+    return {
+        magic,
+        version: dv.getUint8(4),
+        direction: dv.getUint8(5),
+        msgType: dv.getUint8(6),
+        flags: dv.getUint8(7),
+        requestId: dv.getUint32(8, true),
+        handlerId: dv.getUint32(12, true),
+        payloadLen: dv.getUint32(16, true),
+        statusCode: dv.getUint32(20, true),
+        reserved: new Uint8Array(buf, 24, 8),
+    };
+}
+/**
+ * Read a header from an ArrayBuffer-like source.
+ */
+export function readHeader(buffer) {
+    return decodeHeader(buffer);
+}
+/**
+ * Create a new Header with sensible defaults.
+ */
+export function newHeader(direction, msgType, requestId, handlerId, statusCode, payloadLen) {
+    return {
+        magic: MAGIC,
+        version: 0x01,
+        direction,
+        msgType,
+        flags: 0,
+        requestId,
+        handlerId,
+        payloadLen,
+        statusCode,
+        reserved: new Uint8Array(8),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { calculateLayout } from "./layout.js";
+export { encodeHeader, decodeHeader, readHeader, newHeader } from "./header.js";
+export { serializeOutput, deserializeInput } from "./serialize.js";
+export { FieldType, FieldCategory, Direction, MessageType, MAGIC, HEADER_SIZE, SENTINEL_ABSENT, } from "./types.js";
+export type { FieldLayout, CompiledLayout, Header } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEnE,OAAO,EACL,SAAS,EACT,aAAa,EACb,SAAS,EACT,WAAW,EACX,KAAK,EACL,WAAW,EACX,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { calculateLayout } from "./layout.js";
+export { encodeHeader, decodeHeader, readHeader, newHeader } from "./header.js";
+export { serializeOutput, deserializeInput } from "./serialize.js";
+export { FieldType, FieldCategory, Direction, MessageType, MAGIC, HEADER_SIZE, SENTINEL_ABSENT, } from "./types.js";

package/dist/layout.d.ts

@@ -0,0 +1,8 @@
+import type { ObjectIR } from "@antines/schema";
+import { type CompiledLayout } from "./types.js";
+/**
+ * Calculate the wire format layout from a SchemaIR object schema.
+ * Mirrors Go's CalculateLayout.
+ */
+export declare function calculateLayout(s: ObjectIR): CompiledLayout;
+//# sourceMappingURL=layout.d.ts.map

package/dist/layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../src/layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAA8C,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAwC7F;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,QAAQ,GAAG,cAAc,CAkD3D"}

package/dist/layout.js

@@ -0,0 +1,88 @@
+import { FieldType, FieldCategory } from "./types.js";
+/**
+ * Resolve a SchemaIR node to its wire type, category, and fixed size.
+ * Mirrors Go's fieldTypeAndSize.
+ */
+function fieldTypeAndSize(s) {
+    switch (s.type) {
+        case "string":
+            return [FieldType.String, FieldCategory.Variable, 0];
+        case "number":
+            return [FieldType.Number, FieldCategory.Fixed, 8];
+        case "boolean":
+            return [FieldType.Boolean, FieldCategory.Fixed, 1];
+        case "enum":
+            return [FieldType.Enum, FieldCategory.Fixed, 2];
+        case "date":
+            return [FieldType.Date, FieldCategory.Fixed, 8];
+        case "array":
+            return [FieldType.Array, FieldCategory.Variable, 0];
+        case "object":
+            return [FieldType.Object, FieldCategory.Variable, 0];
+        case "nullable": {
+            if (!s.inner)
+                throw new Error("nullable: missing inner schema");
+            const [innerType, innerCat, innerSize] = fieldTypeAndSize(s.inner);
+            if (innerCat === FieldCategory.Fixed) {
+                return [innerType, FieldCategory.Fixed, innerSize + 1];
+            }
+            return [innerType, FieldCategory.Variable, 0];
+        }
+        case "optional": {
+            if (!s.inner)
+                throw new Error("optional: missing inner schema");
+            // In object field context: bitmask handles optionality, unwrap to inner type
+            return fieldTypeAndSize(s.inner);
+        }
+        default:
+            throw new Error(`unknown schema type: ${s.type}`);
+    }
+}
+/**
+ * Calculate the wire format layout from a SchemaIR object schema.
+ * Mirrors Go's CalculateLayout.
+ */
+export function calculateLayout(s) {
+    const fields = [];
+    let fixedSize = 0;
+    let bitmaskBit = 0;
+    let variableCount = 0;
+    const fieldNames = s.fieldOrder ?? Object.keys(s.fields);
+    for (const name of fieldNames) {
+        const f = s.fields[name];
+        if (!f)
+            continue;
+        const [ft, cat, size] = fieldTypeAndSize(f.schema);
+        const fl = {
+            name,
+            fieldType: ft,
+            category: cat,
+            offset: 0,
+            size: 0,
+            bitmaskBit: -1,
+            isOptional: f.optional,
+            isNullable: f.nullable,
+        };
+        if (cat === FieldCategory.Fixed) {
+            fl.offset = fixedSize;
+            fl.size = size;
+            fixedSize += size;
+        }
+        else {
+            fl.offset = variableCount;
+            variableCount++;
+        }
+        if (f.optional) {
+            fl.bitmaskBit = bitmaskBit;
+            bitmaskBit++;
+        }
+        fields.push(fl);
+    }
+    const bitmaskSize = bitmaskBit > 0 ? Math.ceil(bitmaskBit / 8) : 0;
+    return {
+        fields,
+        fixedSize,
+        bitmaskSize,
+        variableCount,
+    };
+}

package/dist/serialize.d.ts

@@ -0,0 +1,12 @@
+import { type CompiledLayout } from "./types.js";
+/**
+ * Serialize JS data (Record) into the positional wire format.
+ * Mirrors Go's SerializeInput — used by JS worker to send results.
+ */
+export declare function serializeOutput(layout: CompiledLayout, data: Record<string, unknown>): ArrayBuffer;
+/**
+ * Deserialize the positional wire format into JS data (Record).
+ * Mirrors Go's DeserializeOutput — used by JS worker to receive dispatches.
+ */
+export declare function deserializeInput(layout: CompiledLayout, data: ArrayBuffer): Record<string, unknown>;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../src/serialize.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAEpB,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,WAAW,CAyFb;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,WAAW,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA0CzB"}

package/dist/serialize.js

@@ -0,0 +1,225 @@
+import { FieldType, FieldCategory, SENTINEL_ABSENT, } from "./types.js";
+/**
+ * Serialize JS data (Record) into the positional wire format.
+ * Mirrors Go's SerializeInput — used by JS worker to send results.
+ */
+export function serializeOutput(layout, data) {
+    const bitmaskSize = layout.bitmaskSize;
+    const fixedSize = layout.fixedSize;
+    const varCount = layout.variableCount;
+    // pre-allocate with max possible size
+    const offsetTableSize = varCount * 8;
+    const headerSize = bitmaskSize + fixedSize + offsetTableSize;
+    const buf = new ArrayBuffer(headerSize);
+    const view = new DataView(buf);
+    const bitmask = new Uint8Array(bitmaskSize);
+    const variableOffsets = new Uint32Array(varCount);
+    variableOffsets.fill(SENTINEL_ABSENT);
+    const variableData = [];
+    let variableDataTotal = 0;
+    let varIdx = 0;
+    for (const f of layout.fields) {
+        const val = data[f.name];
+        if (val === undefined || val === null) {
+            if (f.isOptional) {
+                if (f.category === FieldCategory.Variable) {
+                    varIdx++;
+                }
+                continue;
+            }
+        }
+        if (f.isOptional && f.bitmaskBit >= 0 && val !== undefined && val !== null) {
+            const byteIdx = Math.floor(f.bitmaskBit / 8);
+            const bitIdx = f.bitmaskBit % 8;
+            bitmask[byteIdx] |= 1 << bitIdx;
+        }
+        if (f.category === FieldCategory.Fixed) {
+            const offset = bitmaskSize + f.offset;
+            encodeFixedField(f, val, view, offset);
+            continue;
+        }
+        const enc = encodeVariableField(f, val);
+        variableOffsets[varIdx] = variableDataTotal;
+        variableData.push(enc);
+        variableDataTotal += enc.byteLength;
+        varIdx++;
+    }
+    const totalSize = headerSize + variableDataTotal;
+    const finalBuf = new ArrayBuffer(totalSize);
+    const finalView = new DataView(finalBuf);
+    for (let i = 0; i < bitmaskSize; i++) {
+        finalView.setUint8(i, bitmask[i] ?? 0);
+    }
+    if (fixedSize > 0) {
+        const fixedSrc = new Uint8Array(buf, bitmaskSize, fixedSize);
+        const fixedDst = new Uint8Array(finalBuf, bitmaskSize, fixedSize);
+        fixedDst.set(fixedSrc);
+    }
+    let variableStart = bitmaskSize + fixedSize;
+    for (let i = 0; i < varCount; i++) {
+        const start = variableOffsets[i];
+        const offset = variableStart + i * 8;
+        let length = 0;
+        if (start !== SENTINEL_ABSENT) {
+            if (i + 1 < varCount && variableOffsets[i + 1] !== SENTINEL_ABSENT) {
+                length = variableOffsets[i + 1] - start;
+            }
+            else {
+                length = variableDataTotal - start;
+            }
+        }
+        finalView.setUint32(offset, start, true);
+        finalView.setUint32(offset + 4, length, true);
+    }
+    if (variableDataTotal > 0) {
+        const varDst = new Uint8Array(finalBuf, variableStart + varCount * 8);
+        let pos = 0;
+        for (const chunk of variableData) {
+            varDst.set(chunk, pos);
+            pos += chunk.byteLength;
+        }
+    }
+    return finalBuf;
+}
+/**
+ * Deserialize the positional wire format into JS data (Record).
+ * Mirrors Go's DeserializeOutput — used by JS worker to receive dispatches.
+ */
+export function deserializeInput(layout, data) {
+    const result = {};
+    const view = new DataView(data);
+    const bitmaskSize = layout.bitmaskSize;
+    const fixedSize = layout.fixedSize;
+    const varCount = layout.variableCount;
+    let varIdx = 0;
+    for (const f of layout.fields) {
+        if (f.isOptional && f.bitmaskBit >= 0) {
+            const byteIdx = Math.floor(f.bitmaskBit / 8);
+            const bitIdx = f.bitmaskBit % 8;
+            if (byteIdx >= bitmaskSize || ((view.getUint8(byteIdx) >> bitIdx) & 1) === 0) {
+                if (f.category === FieldCategory.Variable) {
+                    varIdx++;
+                }
+                continue;
+            }
+        }
+        if (f.category === FieldCategory.Fixed) {
+            const offset = bitmaskSize + f.offset;
+            result[f.name] = decodeFixedField(f, view, offset);
+        }
+        else {
+            const tableOffset = bitmaskSize + fixedSize + varIdx * 8;
+            const start = view.getUint32(tableOffset, true);
+            const length = view.getUint32(tableOffset + 4, true);
+            if (start !== SENTINEL_ABSENT) {
+                if (length > 0) {
+                    const variableStart = bitmaskSize + fixedSize + varCount * 8;
+                    const fieldBuf = data.slice(variableStart + start, variableStart + start + length);
+                    result[f.name] = decodeVariableField(f, fieldBuf);
+                }
+                else {
+                    result[f.name] = zeroValueForWire(f);
+                }
+            }
+            varIdx++;
+        }
+    }
+    return result;
+}
+// ---- Fixed field encoding ----
+function encodeFixedField(f, val, view, offset) {
+    switch (f.fieldType) {
+        case FieldType.Number: {
+            const num = typeof val === "number" ? val : 0;
+            view.setFloat64(offset, num, true);
+            break;
+        }
+        case FieldType.Boolean: {
+            view.setUint8(offset, val ? 1 : 0);
+            break;
+        }
+        case FieldType.Enum: {
+            const idx = typeof val === "number" ? val : 0;
+            view.setUint16(offset, idx, true);
+            break;
+        }
+        case FieldType.Date: {
+            let ms;
+            if (typeof val === "string") {
+                ms = new Date(val).getTime();
+            }
+            else if (val instanceof Date) {
+                ms = val.getTime();
+            }
+            else if (typeof val === "number") {
+                ms = val;
+            }
+            else {
+                ms = 0;
+            }
+            view.setBigUint64(offset, BigInt(ms), true);
+            break;
+        }
+    }
+}
+function decodeFixedField(f, view, offset) {
+    switch (f.fieldType) {
+        case FieldType.Number:
+            return view.getFloat64(offset, true);
+        case FieldType.Boolean:
+            return view.getUint8(offset) !== 0;
+        case FieldType.Enum:
+            return view.getUint16(offset, true);
+        case FieldType.Date: {
+            const ms = Number(view.getBigUint64(offset, true));
+            return new Date(ms);
+        }
+        default:
+            return null;
+    }
+}
+// ---- Variable field encoding ----
+function encodeVariableField(f, val) {
+    switch (f.fieldType) {
+        case FieldType.String: {
+            const str = typeof val === "string" ? val : String(val ?? "");
+            return new TextEncoder().encode(str);
+        }
+        case FieldType.Array:
+        case FieldType.Object: {
+            const json = JSON.stringify(val ?? {});
+            return new TextEncoder().encode(json);
+        }
+        default:
+            return new TextEncoder().encode(String(val ?? ""));
+    }
+}
+function decodeVariableField(f, buf) {
+    switch (f.fieldType) {
+        case FieldType.String:
+            return new TextDecoder().decode(buf);
+        case FieldType.Array:
+        case FieldType.Object: {
+            try {
+                return JSON.parse(new TextDecoder().decode(buf));
+            }
+            catch {
+                return new TextDecoder().decode(buf);
+            }
+        }
+        default:
+            return new TextDecoder().decode(buf);
+    }
+}
+function zeroValueForWire(f) {
+    switch (f.fieldType) {
+        case FieldType.String:
+            return "";
+        case FieldType.Array:
+            return [];
+        case FieldType.Object:
+            return {};
+        default:
+            return null;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,55 @@
+export declare enum FieldType {
+    String = 0,
+    Number = 1,
+    Boolean = 2,
+    Enum = 3,
+    Date = 4,
+    Array = 5,
+    Object = 6
+}
+export declare enum FieldCategory {
+    Fixed = 0,
+    Variable = 1
+}
+export interface FieldLayout {
+    name: string;
+    fieldType: FieldType;
+    category: FieldCategory;
+    offset: number;
+    size: number;
+    bitmaskBit: number;
+    isOptional: boolean;
+    isNullable: boolean;
+}
+export interface CompiledLayout {
+    fields: FieldLayout[];
+    fixedSize: number;
+    bitmaskSize: number;
+    variableCount: number;
+}
+export declare enum Direction {
+    GoToJS = 0,
+    JSToGo = 1
+}
+export declare enum MessageType {
+    Dispatch = 0,
+    Result = 1,
+    Ping = 2,
+    Error = 3
+}
+export interface Header {
+    magic: number;
+    version: number;
+    direction: Direction;
+    msgType: MessageType;
+    flags: number;
+    requestId: number;
+    handlerId: number;
+    payloadLen: number;
+    statusCode: number;
+    reserved: Uint8Array;
+}
+export declare const MAGIC = 1095652435;
+export declare const HEADER_SIZE = 32;
+export declare const SENTINEL_ABSENT = 4294967295;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AACA,oBAAY,SAAS;IACnB,MAAM,IAAI;IACV,MAAM,IAAI;IACV,OAAO,IAAI;IACX,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;IACT,MAAM,IAAI;CACX;AAGD,oBAAY,aAAa;IACvB,KAAK,IAAI;IACT,QAAQ,IAAI;CACb;AAGD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;CACrB;AAGD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACvB;AAGD,oBAAY,SAAS;IACnB,MAAM,IAAO;IACb,MAAM,IAAO;CACd;AAED,oBAAY,WAAW;IACrB,QAAQ,IAAO;IACf,MAAM,IAAO;IACb,IAAI,IAAO;IACX,KAAK,IAAO;CACb;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,WAAW,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,UAAU,CAAC;CACtB;AAED,eAAO,MAAM,KAAK,aAAa,CAAC;AAChC,eAAO,MAAM,WAAW,KAAK,CAAC;AAC9B,eAAO,MAAM,eAAe,aAAa,CAAC"}

package/dist/types.js

@@ -0,0 +1,33 @@
+// Mirrors Go's FieldType
+export var FieldType;
+(function (FieldType) {
+    FieldType[FieldType["String"] = 0] = "String";
+    FieldType[FieldType["Number"] = 1] = "Number";
+    FieldType[FieldType["Boolean"] = 2] = "Boolean";
+    FieldType[FieldType["Enum"] = 3] = "Enum";
+    FieldType[FieldType["Date"] = 4] = "Date";
+    FieldType[FieldType["Array"] = 5] = "Array";
+    FieldType[FieldType["Object"] = 6] = "Object";
+})(FieldType || (FieldType = {}));
+// Mirrors Go's FieldCategory
+export var FieldCategory;
+(function (FieldCategory) {
+    FieldCategory[FieldCategory["Fixed"] = 0] = "Fixed";
+    FieldCategory[FieldCategory["Variable"] = 1] = "Variable";
+})(FieldCategory || (FieldCategory = {}));
+// Mirrors Go's Header
+export var Direction;
+(function (Direction) {
+    Direction[Direction["GoToJS"] = 0] = "GoToJS";
+    Direction[Direction["JSToGo"] = 1] = "JSToGo";
+})(Direction || (Direction = {}));
+export var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["Dispatch"] = 0] = "Dispatch";
+    MessageType[MessageType["Result"] = 1] = "Result";
+    MessageType[MessageType["Ping"] = 2] = "Ping";
+    MessageType[MessageType["Error"] = 3] = "Error";
+})(MessageType || (MessageType = {}));
+export const MAGIC = 0x414e5453;
+export const HEADER_SIZE = 32;
+export const SENTINEL_ABSENT = 0xffffffff;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@antines/protocol",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "check-types": "tsc --noEmit",
+    "lint": "oxlint"
+  },
+  "dependencies": {
+    "@antines/schema": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/antines-labs/antinesjs.git",
+    "directory": "packages/protocol"
+  }
+}