/| ` HTML skeleton token-by-token; cell text is
+// filled in later from the region's OCR lines (fillTableCells).
+function recognizeTableStructure(
+ model: Model,
+ preprocessor: ImagePreprocessor,
+ state: TableDecodeState,
+ tableConfig: TableConfig,
+ page: Tensor,
+ format: ImageFormat
+): string {
+ 'worklet';
+ const { structureVocab, eosTokenId, maxSteps } = tableConfig;
+ const { tFeatures, tHidden, tOnehot, tProbs, tNewHidden } = state;
+ const tInput = preprocessor.processTensor(page, format);
+ model.execute('table_encode', [tInput], [tFeatures]);
+ tHidden.setData(state.zeroHidden);
+ // First step feeds an all-zero one-hot, not a 'sos' (index-0) one-hot: the
+ // exported decoder embeds its own start token, so the first real input is the
+ // zero vector. (Validated on-device — a 'sos' one-hot here would offset every
+ // decoded token by one. Revisit if a re-export changes the decoder's start.)
+ tOnehot.setData(state.zeroVocab);
+ let html = '';
+ for (let step = 0; step < maxSteps; step++) {
+ model.execute('table_decode_step', [tFeatures, tHidden, tOnehot], [tProbs, tNewHidden]);
+ tProbs.getData(state.probsBuf);
+ const tok = argmax(state.probsBuf);
+ if (tok === eosTokenId) {
+ break;
+ }
+ // Drop the reserved start/end token range from the assembled skeleton.
+ if (tok > 0 && tok < eosTokenId && tok < structureVocab.length) {
+ html += structureVocab[tok]!;
+ }
+ tNewHidden.copyTo(tHidden);
+ state.onehotBuf.fill(0);
+ state.onehotBuf[tok] = 1;
+ tOnehot.setData(state.onehotBuf);
+ }
+ return html;
+}
+
+// Clusters 1-D values into `k` groups at the k-1 widest gaps, each reduced to its
+// mean — matches how table cells distribute (tight within a row/col, gaps between).
+function clusterByGaps(values: readonly number[], k: number): number[] {
+ 'worklet';
+ if (k < 1) {
+ return [];
+ }
+ const sorted = [...values].sort((a, b) => a - b);
+ if (sorted.length <= k) {
+ return sorted;
+ }
+ const gaps = sorted.slice(1).map((value, i) => ({ at: i + 1, size: value - sorted[i]! }));
+ gaps.sort((a, b) => b.size - a.size);
+ const cuts = gaps
+ .slice(0, k - 1)
+ .map((gap) => gap.at)
+ .sort((a, b) => a - b);
+ const centers: number[] = [];
+ let prev = 0;
+ for (const cut of [...cuts, sorted.length]) {
+ const group = sorted.slice(prev, cut);
+ centers.push(group.reduce((sum, value) => sum + value, 0) / group.length);
+ prev = cut;
+ }
+ return centers;
+}
+
+// Fills a table skeleton's cells with a region's OCR lines, assigning each line's
+// box center to its nearest row/column cluster (document-order fallback if no grid).
+// Known limit: a line whose center falls inside a rowspan's vertical extent lands
+// on a row where that column has no | (the span occupies it), so its text is
+// dropped — occupancy is tracked, content routing into spanned cells is not.
+export function fillTableCells(html: string, lines: readonly OcrDetection[]): string {
+ 'worklet';
+ const rowCount = (html.match(/ |