CPU and memory
profiling.

export class SearchSession {
	private documents: Document[];
	private index: string[] | null;
	readonly history: number[][] = [];
	normalizedDocuments = 0;
	scannedDocuments = 0;
	createdResultSlots = 0;
	private keepHistory: boolean;

	constructor(documents: Document[], mode: Mode) {
		// Take a snapshot: edits require a new session and index.
		this.documents = documents.map((document) => ({ ...document }));
		this.keepHistory = mode === 'baseline' || mode === 'index';
		this.index =
			mode === 'index' || mode === 'both'
				? this.documents.map((document) => {
						this.normalizedDocuments++;
						return normalize(document.text);
					})
				: null;
	}

	search(query: string): number[] {
		const needle = normalize(query);
		const ids: number[] = [];
		for (let i = 0; i < this.documents.length; i++) {
			this.scannedDocuments++;
			let text = this.index?.[i];
			if (text === undefined) {
				this.normalizedDocuments++;
				text = normalize(this.documents[i].text);
			}
			if (text.includes(needle)) ids.push(this.documents[i].id);
		}
		this.createdResultSlots += ids.length;
		if (!this.keepHistory) this.history.length = 0;
		this.history.push(ids);
		return ids;
	}

	inspect() {
		return {
			normalizedDocuments: this.normalizedDocuments,
			scannedDocuments: this.scannedDocuments,
			createdResultSlots: this.createdResultSlots,
			retainedResultSlots: this.history.reduce((sum, ids) => sum + ids.length, 0),
			retainedBatches: this.history.length,
			indexEntries: this.index?.length ?? 0
		};
	}
}

type SearchSession struct {
	documents                                                 []Document
	index                                                     []string
	history                                                   [][]int
	keepHistory                                               bool
	normalizedDocuments, scannedDocuments, createdResultSlots int
}

func NewSession(documents []Document, mode string) *SearchSession {
	s := &SearchSession{documents: append([]Document(nil), documents...), keepHistory: mode == "baseline" || mode == "index"}
	if mode == "index" || mode == "both" {
		s.index = make([]string, len(documents))
		for i, document := range s.documents {
			s.index[i] = normalize(document.Text)
			s.normalizedDocuments++
		}
	}
	return s
}

func (s *SearchSession) Search(query string) []int {
	needle := normalize(query)
	ids := make([]int, 0)
	for i, document := range s.documents {
		s.scannedDocuments++
		var text string
		if s.index != nil {
			text = s.index[i]
		} else {
			text = normalize(document.Text)
			s.normalizedDocuments++
		}
		if strings.Contains(text, needle) {
			ids = append(ids, document.ID)
		}
	}
	s.createdResultSlots += len(ids)
	if !s.keepHistory {
		s.history = nil
	}
	s.history = append(s.history, ids)
	return ids
}

export function replay(session: SearchSession, queries: string[]): number {
	let matches = 0;
	for (const query of queries) matches += session.search(query).length;
	return matches;
}

export function example(mode: Mode = 'baseline') {
	const session = new SearchSession(makeDocuments(1000), mode);
	const matches = replay(session, makeQueries(24));
	return { mode, matches, ...session.inspect() };
}

func Replay(s *SearchSession, queries []string) int {
	matches := 0
	for _, query := range queries {
		matches += len(s.Search(query))
	}
	return matches
}
func main() {
	for _, mode := range []string{"baseline", "index", "release", "both"} {
		s := NewSession(MakeDocuments(1000), mode)
		fmt.Println(mode, "matches:", Replay(s, MakeQueries(24)), "stats:", s.Inspect())
	}
}

export type Document = { id: number; text: string };
export type Mode = 'baseline' | 'index' | 'release' | 'both';
export const modes: Mode[] = ['baseline', 'index', 'release', 'both'];
export const queryCycle = [
	'FACTORY',
	' service ',
	'stack',
	'missing',
	'',
	'go',
	'memory',
	'factory'
];

// ASCII-only fixture: no locale, Unicode case-folding, or search ranking contract.
export function normalize(text: string): string {
	return text.replace(/^[ \t\r\n]+|[ \t\r\n]+$/g, '').toLowerCase();
}

export class SearchSession {
	private documents: Document[];
	private index: string[] | null;
	readonly history: number[][] = [];
	normalizedDocuments = 0;
	scannedDocuments = 0;
	createdResultSlots = 0;
	private keepHistory: boolean;

	constructor(documents: Document[], mode: Mode) {
		// Take a snapshot: edits require a new session and index.
		this.documents = documents.map((document) => ({ ...document }));
		this.keepHistory = mode === 'baseline' || mode === 'index';
		this.index =
			mode === 'index' || mode === 'both'
				? this.documents.map((document) => {
						this.normalizedDocuments++;
						return normalize(document.text);
					})
				: null;
	}

	search(query: string): number[] {
		const needle = normalize(query);
		const ids: number[] = [];
		for (let i = 0; i < this.documents.length; i++) {
			this.scannedDocuments++;
			let text = this.index?.[i];
			if (text === undefined) {
				this.normalizedDocuments++;
				text = normalize(this.documents[i].text);
			}
			if (text.includes(needle)) ids.push(this.documents[i].id);
		}
		this.createdResultSlots += ids.length;
		if (!this.keepHistory) this.history.length = 0;
		this.history.push(ids);
		return ids;
	}

	inspect() {
		return {
			normalizedDocuments: this.normalizedDocuments,
			scannedDocuments: this.scannedDocuments,
			createdResultSlots: this.createdResultSlots,
			retainedResultSlots: this.history.reduce((sum, ids) => sum + ids.length, 0),
			retainedBatches: this.history.length,
			indexEntries: this.index?.length ?? 0
		};
	}
}


export function makeDocuments(count: number): Document[] {
	const topics = [
		'Factory service TypeScript',
		'Stack memory Go',
		'Graph service Rust',
		'Queue memory Go'
	];
	return Array.from({ length: count }, (_, id) => ({
		id,
		text: `  ${topics[id % topics.length]} lesson ${id}  `
	}));
}

export function makeQueries(count: number): string[] {
	return Array.from({ length: count }, (_, i) => queryCycle[i % queryCycle.length]);
}

export function replay(session: SearchSession, queries: string[]): number {
	let matches = 0;
	for (const query of queries) matches += session.search(query).length;
	return matches;
}

export function example(mode: Mode = 'baseline') {
	const session = new SearchSession(makeDocuments(1000), mode);
	const matches = replay(session, makeQueries(24));
	return { mode, matches, ...session.inspect() };
}

console.log(example());

package main

import (
	"fmt"
	"strings"
)

type Document struct {
	ID   int    `json:"id"`
	Text string `json:"text"`
}

func normalize(text string) string { return strings.ToLower(strings.Trim(text, " \t\r\n")) }

type SearchSession struct {
	documents                                                 []Document
	index                                                     []string
	history                                                   [][]int
	keepHistory                                               bool
	normalizedDocuments, scannedDocuments, createdResultSlots int
}

func NewSession(documents []Document, mode string) *SearchSession {
	s := &SearchSession{documents: append([]Document(nil), documents...), keepHistory: mode == "baseline" || mode == "index"}
	if mode == "index" || mode == "both" {
		s.index = make([]string, len(documents))
		for i, document := range s.documents {
			s.index[i] = normalize(document.Text)
			s.normalizedDocuments++
		}
	}
	return s
}

func (s *SearchSession) Search(query string) []int {
	needle := normalize(query)
	ids := make([]int, 0)
	for i, document := range s.documents {
		s.scannedDocuments++
		var text string
		if s.index != nil {
			text = s.index[i]
		} else {
			text = normalize(document.Text)
			s.normalizedDocuments++
		}
		if strings.Contains(text, needle) {
			ids = append(ids, document.ID)
		}
	}
	s.createdResultSlots += len(ids)
	if !s.keepHistory {
		s.history = nil
	}
	s.history = append(s.history, ids)
	return ids
}


type Stats struct{ NormalizedDocuments, ScannedDocuments, CreatedResultSlots, RetainedResultSlots, RetainedBatches, IndexEntries int }

func (s *SearchSession) Inspect() Stats {
	retained := 0
	for _, ids := range s.history {
		retained += len(ids)
	}
	return Stats{s.normalizedDocuments, s.scannedDocuments, s.createdResultSlots, retained, len(s.history), len(s.index)}
}
func MakeDocuments(count int) []Document {
	topics := []string{"Factory service TypeScript", "Stack memory Go", "Graph service Rust", "Queue memory Go"}
	docs := make([]Document, count)
	for i := range docs {
		docs[i] = Document{i, fmt.Sprintf("  %s lesson %d  ", topics[i%len(topics)], i)}
	}
	return docs
}
func MakeQueries(count int) []string {
	cycle := []string{"FACTORY", " service ", "stack", "missing", "", "go", "memory", "factory"}
	queries := make([]string, count)
	for i := range queries {
		queries[i] = cycle[i%len(cycle)]
	}
	return queries
}

func Replay(s *SearchSession, queries []string) int {
	matches := 0
	for _, query := range queries {
		matches += len(s.Search(query))
	}
	return matches
}
func main() {
	for _, mode := range []string{"baseline", "index", "release", "both"} {
		s := NewSession(MakeDocuments(1000), mode)
		fmt.Println(mode, "matches:", Replay(s, MakeQueries(24)), "stats:", s.Inspect())
	}
}