Solid-State Thermal
Oscillation Control

; ── STOC v0.1 INSTRUCTION SET ─────────────────────────────
stoc.init      ring    N=128  R=5mm  layers=8
stoc.load      pmx.reg process_matrix
stoc.set.mode  m=1                     ; azimuthal wave number
stoc.set.freq  omega=2.5e3             ; rad/s
stoc.dir       cw | ccw                ; Nernst gate
stoc.heat.push segment=k  amount=q     ; single-junction pulse
stoc.heat.pull segment=k  amount=q     ; symmetric cool pulse
stoc.oscillate cycles=n                ; run n periods
stoc.read.T    theta -> T_out.reg      ; T(theta) via IR plane
stoc.read.dft  N_harm -> spec.reg      ; Fourier amplitudes
stoc.settle    tau                     ; wait for equilibrium
stoc.dispatch  poi.sig -> receipt      ; sign and settle

; anomaly.score(v) on the ring — canonical NWO-ASM path
  use stoc as target
  let W = pmx.lift( v )                ; encode as process matrix
  stoc.init ring N=128 R=5mm layers=8
  stoc.load  pmx.reg W
  stoc.set.mode  m=1
  stoc.set.freq  omega=2.5e3
  stoc.dir cw
  stoc.oscillate cycles=32
  stoc.read.dft  8 -> spec
  let score = free_energy_bound( spec )
  stoc.dispatch poi -> anchor(base)    ; USDC settlement, splitter
  return (score, poi.sig)

[substrate.stoc]
status         = "DESIGN"           # flips to LIVE after Q4 2026
endpoint       = "http://stoc.local:7412/v1"
authentication = "bearer"            # api_key from MetaState registration
settlement     = "base:8453"         # same splitter as ASI & Metaverse
affiliate      = true                 # 15% via same splitter
capabilities   = [
  "stoc.init", "stoc.load", "stoc.set.mode", "stoc.set.freq",
  "stoc.dir", "stoc.heat.push", "stoc.heat.pull", "stoc.oscillate",
  "stoc.read.T", "stoc.read.dft", "stoc.settle", "stoc.dispatch"
]

// stoc_pwm.v — 24-channel phase-shifted PWM engine · MIT · v0.1
module stoc_pwm #(
    parameter N     = 24,
    parameter PERIOD = 5000    // 20 kHz @ 100 MHz clk
)(
    input  clk,
    input  rst,
    input  [15:0] i0_amp,       // drive amplitude
    input  [15:0] omega,        // scaled angular freq
    input  [3:0]  m_mode,       // azimuthal mode
    output [N-1:0] pwm_out
);
  reg [31:0] phase [0:N-1];
  reg [15:0] duty  [0:N-1];
  reg [15:0] counter;

  integer i;
  always @(posedge clk) begin
    if (rst) begin
      counter <= 0;
      for (i=0; i<N; i=i+1) phase[i] <= i * (32'h1_0000_0000 / N);
    end else begin
      counter <= (counter == PERIOD-1) ? 0 : counter + 1;
      for (i=0; i<N; i=i+1) begin
        phase[i] <= phase[i] + (omega * m_mode);
        duty[i]  <= cos_lut(phase[i][31:22]) * i0_amp >> 12;
      end
    end
  end

  genvar g;
  generate for (g=0; g<N; g=g+1)
    assign pwm_out[g] = (counter < duty[g]) ? 1'b1 : 1'b0;
  endgenerate
endmodule

// stoc_host.rs — MIT · v0.1 · axum + tokio + serialport
use axum::{Router, routing::post, Json};
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct DispatchReq {
    process_matrix: Vec<Vec<f32>>,
    mode: u32,           // m ∈ {0,1,2,…}
    omega: f32,          // rad/s
    dir: "cw" | "ccw",
    cycles: u32,
}

#[derive(Serialize)]
struct DispatchResp {
    harmonics: Vec<(f32, f32)>,   // (Re, Im) per harmonic
    receipt:   String,             // Ed25519 signature
    backend:   String,             // "stoc:tabletop-v1"
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/v1/dispatch", post(dispatch))
        .route("/v1/read",     post(read_dft))
        .route("/v1/verify",   post(verify));
    axum::Server::bind(&"0.0.0.0:7412".parse().unwrap())
        .serve(app.into_make_service()).await.unwrap();
}