@oquen/protocol 2.0.0

package/ACTBase.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Base struct (Abstraction) of the ACT state engine.
+ * Manages the 64-byte hardware register mapping.
+ */
+export declare class ACTBase {
+    typeHash: bigint;
+    dataPtr: bigint;
+    dataSize: bigint;
+    metadata: number;
+    private _command;
+    stateBitmask: number;
+    x: number;
+    y: number;
+    z: number;
+    tx: number;
+    ty: number;
+    tz: number;
+    currentFrame: bigint;
+    internalSetCommand(cmd: number, data?: number): void;
+    setCommand(cmd: number, data?: number): void;
+    get command(): number;
+    pack(): ArrayBuffer;
+}

package/ACTBase.js

@@ -0,0 +1,51 @@
+/**
+ * Base struct (Abstraction) of the ACT state engine.
+ * Manages the 64-byte hardware register mapping.
+ */
+export class ACTBase {
+    constructor() {
+        this.typeHash = 0n;
+        this.dataPtr = 0n;
+        this.dataSize = 0n;
+        this.metadata = 0;
+        this._command = 0;
+        this.stateBitmask = 0;
+        this.x = 0;
+        this.y = 0;
+        this.z = 0;
+        this.tx = 0;
+        this.ty = 0;
+        this.tz = 0;
+        this.currentFrame = 0n;
+    }
+    internalSetCommand(cmd, data = 0) {
+        this.metadata = data;
+        this._command = cmd;
+    }
+    setCommand(cmd, data = 0) {
+        if (cmd < 100) {
+            throw new Error("OXP FATAL: Access Denied. Commands 0-99 are System Reserved.");
+        }
+        this.metadata = data;
+        this._command = cmd;
+    }
+    get command() { return this._command; }
+    pack() {
+        const buffer = new ArrayBuffer(64);
+        const view = new DataView(buffer);
+        view.setBigUint64(0, this.typeHash, true);
+        view.setBigUint64(8, this.dataPtr, true);
+        view.setBigUint64(16, this.dataSize, true);
+        view.setUint16(24, this.metadata, true);
+        view.setUint16(26, this._command, true);
+        view.setUint32(28, this.stateBitmask, true);
+        view.setFloat32(32, this.x, true);
+        view.setFloat32(36, this.y, true);
+        view.setFloat32(40, this.z, true);
+        view.setFloat32(44, this.tx, true);
+        view.setFloat32(48, this.ty, true);
+        view.setFloat32(52, this.tz, true);
+        view.setBigInt64(56, this.currentFrame, true);
+        return buffer;
+    }
+}

package/ACTBase.ts

@@ -0,0 +1,53 @@
+/**
+ * Base struct (Abstraction) of the ACT state engine.
+ * Manages the 64-byte hardware register mapping.
+ */
+export class ACTBase {
+    public typeHash: bigint = 0n;
+    public dataPtr: bigint = 0n;
+    public dataSize: bigint = 0n;
+    public metadata: number = 0;
+    private _command: number = 0;
+    public stateBitmask: number = 0;
+    public x: number = 0;
+    public y: number = 0;
+    public z: number = 0;
+    public tx: number = 0;
+    public ty: number = 0;
+    public tz: number = 0;
+    public currentFrame: bigint = 0n;
+
+    public internalSetCommand(cmd: number, data: number = 0): void {
+        this.metadata = data;
+        this._command = cmd;
+    }
+
+    public setCommand(cmd: number, data: number = 0): void {
+        if (cmd < 100) {
+            throw new Error("OXP FATAL: Access Denied. Commands 0-99 are System Reserved.");
+        }
+        this.metadata = data;
+        this._command = cmd;
+    }
+
+    public get command(): number { return this._command; }
+
+    public pack(): ArrayBuffer {
+        const buffer = new ArrayBuffer(64);
+        const view = new DataView(buffer);
+        view.setBigUint64(0, this.typeHash, true);
+        view.setBigUint64(8, this.dataPtr, true);
+        view.setBigUint64(16, this.dataSize, true);
+        view.setUint16(24, this.metadata, true);
+        view.setUint16(26, this._command, true);
+        view.setUint32(28, this.stateBitmask, true);
+        view.setFloat32(32, this.x, true);
+        view.setFloat32(36, this.y, true);
+        view.setFloat32(40, this.z, true);
+        view.setFloat32(44, this.tx, true);
+        view.setFloat32(48, this.ty, true);
+        view.setFloat32(52, this.tz, true);
+        view.setBigInt64(56, this.currentFrame, true);
+        return buffer;
+    }
+}

package/OXP.d.ts

@@ -0,0 +1,2 @@
+export declare class OXP {
+}

package/OXP.js

@@ -0,0 +1,3 @@
+const DEFAULT_MASTER = "wss://zero.oquen.net/pulse";
+export class OXP {
+}

package/OXP.ts

@@ -0,0 +1,7 @@
+import { ACTBase } from './ACTBase';
+
+const DEFAULT_MASTER = "wss://zero.oquen.net/pulse";
+
+export class OXP {
+   
+}

package/Readme.md

@@ -0,0 +1,100 @@
+# OQUEN (OKEN) ACT: Hardware Accelerated Logic (OXP)
+
+Welcome to a new paradigm in system architecture. With **OQUEN OXP**, we erase layers of software, API gateways, and JSON parsing. Your Next.js app doesn't communicate with a server—it writes directly into hardware registers via the **ZERO Master Node**.
+
+## The Architecture
+
+An **ACT** (Accelerated Control Template) is a 64-byte binary container mirrored to the silicon in real-time. You program in TypeScript; you execute at silicon speed.
+
+- **No REST/GraphQL:** No endpoints to manage.
+- **No JSON:** Zero software overhead.
+- **Hardware Sandbox:** The silicon ignores invalid commands. The server cannot crash.
+- **0.5ns Precision:** Time and Identity are the same thing.
+
+---
+
+In OQUEN, you don't use a fixed API. You build a **TypeScript Class** that wraps the raw **ACTBase** register. You map your own methods to Command IDs.
+
+## 🧠 Persistent Silicon Memory
+
+Unlike traditional stateless APIs, OQUEN is **Stateful by Design**.
+
+- **Sticky State**: Once you set a value (like `x = 440`), it stays in the hardware register. You don't need to re-send it in every pulse.
+- **Session Lifetime**: Your state lives as long as your app is open.
+- **Automatic Cleanup**: The moment the user closes the tab or the Space client, the register is zeroed out (Unregistered).
+- Save state can be handled by using a local OQUEN if you want to remain states (At least for now).
+
+**Think of the ZERO Register as your app's physical memory in the cloud.**
+
+### 1. Build your Custom ACT Class
+
+This is where you define what your commands (501, 502, etc.) actually do.
+
+## Quick Start: Building your first Synth-ACT
+
+```typescript
+# OQUEN: Custom ACT Implementation
+
+import { ACTBase } from '@oquen/protocol';
+
+export class ACTSynth {
+    constructor(private base: ACTBase) {}
+
+    // Continuous updates (Direct Register Mapping)
+    set frequency(val: number) { this.base.x = val; }
+    set resonance(val: number) { this.base.y = val; }
+
+    // Discrete Commands (Direct Hardware Triggers)
+    play(note: number) {
+        this.base.metadata = note;
+        this.base.command = 501; // Command: START
+    }
+
+    pause() {
+        this.base.command = 502; // Command: PAUSE
+    }
+
+    setWaveform(type: number) {
+        this.base.metadata = type;
+        this.base.command = 504; // Command: WAVEFORM
+    }
+}
+
+```
+
+# ⚡ OQUEN: React State Integration
+
+To make development effortless in Next.js, OQUEN mirrors your **React State** directly into the **Silicon Register**. You don't manage buffers; you manage state.
+
+## 1. The Controller Logic
+
+Create a hook or a class that syncs your UI state with the hardware offsets.
+
+```typescript
+import { useState, useEffect } from 'react';
+import { OXP, ACTBase } from '@oquen/protocol';
+
+export function useOquenSynth() {
+    const [synth, setSynth] = useState<ACTSynth | null>(null);
+
+    // Initialize the Hardware Bridge
+    useEffect(() => {
+        OXP.connect('auto').then(stream => {
+            setSynth(new ACTSynth(stream));
+        });
+    }, []);
+
+    // The Magic: A single function to update UI and Silicon simultaneously
+    const updateFrequency = (value: number) => {
+        if (!synth) return;
+        
+        // 1. Update Native Hardware Register
+        synth.frequency = value; 
+        
+        // 2. Update React State for UI feedback
+        // (Optional: only if you need to display the value in text)
+    };
+
+    return { synth, updateFrequency };
+}
+```

package/go.mod

@@ -0,0 +1,3 @@
+module oquen.net/protocol
+
+go 1.21

package/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * OXPHeader v2.2 - Hardware Mapping
+ */
+export declare const OXPHeader: any;
+/**
+ * execute_pulse: Bryggan till din C# OnPulse-logik
+ */
+export declare const onPulse: (header: any) => any;
+import { OXP } from './OXP';
+import { ACTBase } from './ACTBase';
+export { OXP, ACTBase };

package/index.js

@@ -0,0 +1,55 @@
+import * as path from 'path';
+// Vi använder require för koffi för att undvika problem i miljöer där det inte finns
+const koffi = typeof window === 'undefined' ? require('koffi') : null;
+// Sökväg till din Master-kärna
+const dllPath = path.resolve(__dirname, '../OXP.Protocol/bin/Release/net10.0/win-x64/OXPProtocol.dll');
+const isNode = typeof window === 'undefined';
+let lib = null;
+// Försök ladda DLL endast om vi är i Node (Lokal Master/Test)
+if (isNode && koffi) {
+    try {
+        lib = koffi.load(dllPath);
+    }
+    catch (e) {
+        console.warn("OXP: Local DLL not found, running in Network Mode.");
+    }
+}
+/**
+ * OXPHeader v2.2 - Hardware Mapping
+ */
+export const OXPHeader = (isNode && koffi) ? koffi.struct('OXPHeader', {
+    AppKeyHash: 'uint64', // 8b
+    Timestamp: 'int64', // 8b
+    EntryCount: 'int64', // 8b
+    Version: 'uint8', // 1b
+    CpuTemp: 'uint8', // 1b
+    AutoPilot: 'uint8', // 1b
+    NextPulse: 'uint16', // 2b
+    ClientSessionId: 'uint32', // 4b
+    PerformanceNs: 'double', // 8b
+    PulseState: 'uint8', // 1b
+    Zone: 'uint8', // 1b (New v2.2)
+    ProviderID: 'uint64' // 8b (New v2.2)
+}) : null;
+/**
+ * execute_pulse: Bryggan till din C# OnPulse-logik
+ */
+export const onPulse = (header) => {
+    if (!lib || !OXPHeader) {
+        // Om vi kör i browsern (Next.js), skickar vi bara till ZERO MASTER via WSS
+        return { status: 'WEB_MODE', msg: 'Streaming to zero.oquen.net' };
+    }
+    try {
+        // Anropa din NativeAOT-binary direkt i kisel-fart
+        const execute_pulse = lib.func('execute_pulse', 'int', [koffi.pointer(OXPHeader)]);
+        return execute_pulse(header);
+    }
+    catch (err) {
+        console.error("OXP: Native Pulse Failure", err);
+        return -1;
+    }
+};
+// Exponera ACTBase-motorn
+import { OXP } from './OXP';
+import { ACTBase } from './ACTBase';
+export { OXP, ACTBase };

package/index.ts

@@ -0,0 +1,61 @@
+import * as path from 'path';
+// Vi använder require för koffi för att undvika problem i miljöer där det inte finns
+const koffi = typeof window === 'undefined' ? require('koffi') : null;
+
+// Sökväg till din Master-kärna
+const dllPath = path.resolve(__dirname, '../OXP.Protocol/bin/Release/net10.0/win-x64/OXPProtocol.dll');
+
+const isNode = typeof window === 'undefined';
+let lib: any = null;
+
+// Försök ladda DLL endast om vi är i Node (Lokal Master/Test)
+if (isNode && koffi) {
+    try {
+        lib = koffi.load(dllPath);
+    } catch (e) {
+        console.warn("OXP: Local DLL not found, running in Network Mode.");
+    }
+}
+
+/**
+ * OXPHeader v2.2 - Hardware Mapping
+ */
+export const OXPHeader = (isNode && koffi) ? koffi.struct('OXPHeader', {
+    AppKeyHash: 'uint64',      // 8b
+    Timestamp: 'int64',        // 8b
+    EntryCount: 'int64',       // 8b
+    Version: 'uint8',          // 1b
+    CpuTemp: 'uint8',          // 1b
+    AutoPilot: 'uint8',        // 1b
+    NextPulse: 'uint16',       // 2b
+    ClientSessionId: 'uint32', // 4b
+    PerformanceNs: 'double',   // 8b
+    PulseState: 'uint8',       // 1b
+    Zone: 'uint8',             // 1b (New v2.2)
+    ProviderID: 'uint64'       // 8b (New v2.2)
+}) : null;
+
+/**
+ * execute_pulse: Bryggan till din C# OnPulse-logik
+ */
+export const onPulse = (header: any) => {
+    if (!lib || !OXPHeader) {
+        // Om vi kör i browsern (Next.js), skickar vi bara till ZERO MASTER via WSS
+        return { status: 'WEB_MODE', msg: 'Streaming to zero.oquen.net' };
+    }
+
+    try {
+        // Anropa din NativeAOT-binary direkt i kisel-fart
+        const execute_pulse = lib.func('execute_pulse', 'int', [koffi.pointer(OXPHeader)]);
+        return execute_pulse(header);
+    } catch (err) {
+        console.error("OXP: Native Pulse Failure", err);
+        return -1;
+    }
+};
+
+// Exponera ACTBase-motorn
+import { OXP } from './OXP';
+import { ACTBase } from './ACTBase';
+
+export { OXP, ACTBase };

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@oquen/protocol",
+  "version": "2.0.0",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "koffi": "^2.15.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://git.oquen.net/OQUEN/protocol"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "eslint": "^10.2.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": [ "ES2020", "DOM", "DOM.Iterable" ],
+    "module": "ESNext",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node"
+  },
+  "include": [ "*.ts" ]
+}