@@ -0,0 +1,114 @@
+import { Reader } from '../buffer/reader.js'
+import { Writer } from '../buffer/writer.js'
+import { error } from '../utils/utils.js'
+
+/**
+ * Decode WOFF2 hmtx transform 1.
+ * 
+ * The hmtx transform stores horizontal metrics in a more compact format:
+ * - A flags byte indicating which data is present
+ * - An array of advance widths for the first numHMetrics glyphs
+ * - An array of left side bearings (either explicit or derived from x_mins)
+ * 
+ * @see https://www.w3.org/TR/WOFF2/#hmtx_table_format
+ */
+export function decodeHmtxTransform1(
+  buff: Uint8Array,
+  numGlyphs: number,
+  numHMetrics: number,
+  xMins: number[],
+): Uint8Array {
+  const view = new Reader(buff)
+
+  // Read flags byte
+  const flags = view.u8()
+
+  // Bit 0: if 0, proportional LSBs are present in the data (read them)
+  //        if 1, proportional LSBs are omitted (use x_mins instead)
+  // Bit 1: if 0, monospace LSBs are present in the data (read them)
+  //        if 1, monospace LSBs are omitted (use x_mins instead)
+  // Bits 2-7: reserved, must be 0
+  const hasProportionalLsbs = (flags & 0x01) === 0
+  const hasMonospaceLsbs = (flags & 0x02) === 0
+
+  // Validate reserved bits
+  if ((flags & 0xfc) !== 0) {
+    error('Invalid hmtx flags: bits 2-7 must be 0')
+  }
+
+  // At least one LSB array must be omitted (replaced by x_mins)
+  if (hasProportionalLsbs && hasMonospaceLsbs) {
+    error('Invalid hmtx transform: both LSB arrays present')
+  }
+
+  if (xMins.length !== numGlyphs) {
+    error(
+      `x_mins array size mismatch: expected ${numGlyphs}, got ${xMins.length}`,
+    )
+  }
+
+  if (numHMetrics < 1) {
+    error('numHMetrics must be at least 1')
+  }
+
+  if (numHMetrics > numGlyphs) {
+    error('numHMetrics cannot exceed numGlyphs')
+  }
+
+  // Read advance widths for the first numHMetrics glyphs
+  const advanceWidths: number[] = []
+  for (let i = 0; i < numHMetrics; i++) {
+    advanceWidths.push(view.u16())
+  }
+
+  // Read or derive left side bearings for proportional glyphs
+  const lsbs: number[] = []
+  for (let i = 0; i < numHMetrics; i++) {
+    if (hasProportionalLsbs) {
+      lsbs.push(view.i16())
+    } else {
+      lsbs.push(xMins[i])
+    }
+  }
+
+  // Read or derive left side bearings for monospace glyphs
+  for (let i = numHMetrics; i < numGlyphs; i++) {
+    if (hasMonospaceLsbs) {
+      lsbs.push(view.i16())
+    } else {
+      lsbs.push(xMins[i])
+    }
+  }
+
+  // Write the reconstructed hmtx table
+  return writeHmtxTable(numGlyphs, numHMetrics, advanceWidths, lsbs)
+}
+
+/**
+ * Write hmtx table in standard OpenType format.
+ * 
+ * Format:
+ * - For first numHMetrics glyphs: uint16 advanceWidth, int16 lsb
+ * - For remaining glyphs: int16 lsb only (advance width is repeated from last)
+ */
+function writeHmtxTable(
+  numGlyphs: number,
+  numHMetrics: number,
+  advanceWidths: number[],
+  lsbs: number[],
+): Uint8Array {
+  const writer = new Writer()
+
+  // Write longHorMetric records (advance width + lsb)
+  for (let i = 0; i < numHMetrics; i++) {
+    writer.u16(advanceWidths[i])
+    writer.i16(lsbs[i])
+  }
+
+  // Write remaining lsb values only
+  for (let i = numHMetrics; i < numGlyphs; i++) {
+    writer.i16(lsbs[i])
+  }
+
+  return writer.toBuffer()
+}
@@ -1,13 +1,14 @@
 import decompress from 'brotli/decompress.js'
 
 import { Reader } from '../buffer/reader.js'
-import { asUint8Array } from '../buffer/utils.js'
+import { asDataView, asUint8Array } from '../buffer/utils.js'
 import { asSfntVersion } from '../enum-utils.js'
 import { buildFont } from '../font-builder.js'
 import { assert, error, sum } from '../utils/utils.js'
 import { writeGlyfTable } from '../writers/glyf.js'
 import { writeLocaTable } from '../writers/loca.js'
 import { decodeGlyfTransform0 } from './glyf-transform.js'
+import { decodeHmtxTransform1 } from './hmtx-transform.js'
 import { KNOWN_TAGS } from './tags.js'
 import { WOFF2_SIGNATURE } from './utils.js'
 
@@ -71,6 +72,11 @@ export function decodeWoff2(buffer: Uint8Array): Uint8Array {
   let locaEncountered = false
   let offset = 0
   const tables: Record<string, Uint8Array> = {}
+  
+  // Store metadata needed for hmtx reconstruction
+  let xMins: number[] = []
+  let numGlyphs = 0
+  let hmtxTransformBuff: Uint8Array | null = null
 
   for (const table of tableInfo) {
     const buff = asUint8Array(data, offset, table.length)
@@ -94,6 +100,10 @@ export function decodeWoff2(buffer: Uint8Array): Uint8Array {
         const { glyphs, indexFormat } = decodeGlyfTransform0(buff)
         tables[table.tag] = writeGlyfTable(glyphs, loca)
         tables.loca = writeLocaTable(loca, indexFormat)
+        
+        // Extract x_mins for hmtx reconstruction
+        numGlyphs = glyphs.length
+        xMins = glyphs.map((g) => g.xMin)
 
         break
       }
@@ -112,8 +122,9 @@ export function decodeWoff2(buffer: Uint8Array): Uint8Array {
           error(`Unrecognized hmtx transform ${table.transform}`)
         }
 
-        error('TODO: decode hmtx transform 1')
-        // decodeHmtxTransform0(``)
+        // We need to defer hmtx decoding until after glyf is decoded
+        // Store the buffer for later processing
+        hmtxTransformBuff = buff
         break
       }
 
@@ -125,6 +136,20 @@ export function decodeWoff2(buffer: Uint8Array): Uint8Array {
   if (loca.length && !locaEncountered) {
     error('Expected entry for loca table after glyf table')
   }
+  
+  // Now process hmtx if it was encountered
+  if (hmtxTransformBuff !== null) {
+    // We need numHMetrics from hhea table
+    if (!tables.hhea) {
+      error('hhea table required for hmtx reconstruction')
+    }
+    
+    // Read numHMetrics from hhea table (at offset 34)
+    const hheaView = asDataView(tables.hhea)
+    const numHMetrics = hheaView.getUint16(34)
+    
+    tables.hmtx = decodeHmtxTransform1(hmtxTransformBuff, numGlyphs, numHMetrics, xMins)
+  }
 
   return buildFont({ sfntVersion: flavor, tables })
 }