diff --git a/src/__tests__/chart-writer.test.ts b/src/__tests__/chart-writer.test.ts
new file mode 100644
index 0000000..9afa46b
--- /dev/null
+++ b/src/__tests__/chart-writer.test.ts
@@ -0,0 +1,191 @@
+/**
+ * Round-trip tests for writeChartFile: Song / SyncTrack / Events / unrecognized
+ * sections. Instrument-track tests land with the follow-up PR that ports
+ * serializeTrackSection.
+ *
+ * All tests exercise the writer only through parseChartAndIni: build a
+ * ParsedChart, write it out, re-parse, and assert on the resulting
+ * ParsedChart. No assertions about the serialized .chart text (CRLF,
+ * quoting, field order, section ordering) — the parser is the source of
+ * truth for observable behavior.
+ */
+
+import { describe, expect, it } from 'vitest'
+
+import { writeChartFile } from '../chart/chart-writer'
+import { createEmptyChart } from '../chart/create-chart'
+import { parseChartAndIni, type ParsedChart } from '../chart/parse-chart-and-ini'
+
+function roundTrip(chart: ParsedChart): ParsedChart {
+	const bytes = new TextEncoder().encode(writeChartFile(chart))
+	const result = parseChartAndIni([{ fileName: 'notes.chart', data: bytes }])
+	if (!result.parsedChart) {
+		throw new Error(`round-trip produced no parsedChart: ${JSON.stringify(result.chartFolderIssues)}`)
+	}
+	return result.parsedChart
+}
+
+describe('writeChartFile round-trip: [Song] metadata', () => {
+	it('preserves chart resolution', () => {
+		const re = roundTrip(createEmptyChart({ resolution: 192 }))
+		expect(re.resolution).toBe(192)
+	})
+
+	it('preserves string metadata fields', () => {
+		const chart = createEmptyChart()
+		chart.metadata.name = 'My Song'
+		chart.metadata.artist = 'Some Band'
+		chart.metadata.album = 'Greatest Hits'
+		chart.metadata.charter = 'Me'
+		chart.metadata.genre = 'Rock'
+		chart.metadata.year = '2024'
+		const re = roundTrip(chart)
+		expect(re.metadata).toMatchObject({
+			name: 'My Song',
+			artist: 'Some Band',
+			album: 'Greatest Hits',
+			charter: 'Me',
+			genre: 'Rock',
+			year: '2024',
+		})
+	})
+
+	it('preserves chart_offset', () => {
+		const chart = createEmptyChart()
+		chart.metadata.chart_offset = 250
+		expect(roundTrip(chart).metadata.chart_offset).toBe(250)
+	})
+
+	it('preserves preview_start_time', () => {
+		const chart = createEmptyChart()
+		chart.metadata.preview_start_time = 30000
+		expect(roundTrip(chart).metadata.preview_start_time).toBe(30000)
+	})
+
+	it('preserves diff_* difficulty fields', () => {
+		const chart = createEmptyChart()
+		chart.metadata.diff_guitar = 5
+		expect(roundTrip(chart).metadata.diff_guitar).toBe(5)
+	})
+
+	it('does not leak ini `delay` into chart_offset', () => {
+		// delay is ini-only; writing a chart with no chart_offset and a `delay`
+		// value must not surface as chart_offset after round-trip.
+		const chart = createEmptyChart()
+		chart.metadata.delay = 999
+		expect(roundTrip(chart).metadata.chart_offset).toBeUndefined()
+	})
+
+	it('does not emit a chart_offset for the value 0', () => {
+		// 0 is the default in-game behavior; the writer skips it so we don't
+		// round-trip 0 as a meaningful Offset.
+		const chart = createEmptyChart()
+		chart.metadata.chart_offset = 0
+		expect(roundTrip(chart).metadata.chart_offset).toBeUndefined()
+	})
+})
+
+describe('writeChartFile round-trip: [SyncTrack]', () => {
+	it('preserves the default tempo and time signature on an empty chart', () => {
+		const re = roundTrip(createEmptyChart())
+		expect(re.tempos.map(t => ({ tick: t.tick, bpm: t.beatsPerMinute }))).toEqual([{ tick: 0, bpm: 120 }])
+		expect(re.timeSignatures.map(ts => ({ tick: ts.tick, n: ts.numerator, d: ts.denominator }))).toEqual([
+			{ tick: 0, n: 4, d: 4 },
+		])
+	})
+
+	it('preserves non-4/4 time signatures', () => {
+		const chart = createEmptyChart({ timeSignature: { numerator: 6, denominator: 8 } })
+		expect(roundTrip(chart).timeSignatures[0]).toMatchObject({ numerator: 6, denominator: 8 })
+	})
+
+	it('preserves multiple tempo changes', () => {
+		const chart = createEmptyChart({ bpm: 140 })
+		chart.tempos.push({ tick: 1920, beatsPerMinute: 200, msTime: 0 })
+		const re = roundTrip(chart)
+		expect(re.tempos.map(t => ({ tick: t.tick, bpm: t.beatsPerMinute }))).toEqual([
+			{ tick: 0, bpm: 140 },
+			{ tick: 1920, bpm: 200 },
+		])
+	})
+
+	it('preserves multiple time-signature changes', () => {
+		const chart = createEmptyChart()
+		chart.timeSignatures.push({ tick: 3840, numerator: 7, denominator: 8, msTime: 0, msLength: 0 })
+		const re = roundTrip(chart)
+		expect(re.timeSignatures.map(ts => ({ t: ts.tick, n: ts.numerator, d: ts.denominator }))).toEqual([
+			{ t: 0, n: 4, d: 4 },
+			{ t: 3840, n: 7, d: 8 },
+		])
+	})
+
+	it('preserves fractional BPM', () => {
+		const chart = createEmptyChart({ bpm: 137.5 })
+		expect(roundTrip(chart).tempos[0].beatsPerMinute).toBe(137.5)
+	})
+
+	it('preserves tempo + TS events that share a tick', () => {
+		const chart = createEmptyChart()
+		chart.tempos.push({ tick: 960, beatsPerMinute: 150, msTime: 0 })
+		chart.timeSignatures.push({ tick: 960, numerator: 3, denominator: 4, msTime: 0, msLength: 0 })
+		const re = roundTrip(chart)
+		expect(re.tempos.find(t => t.tick === 960)?.beatsPerMinute).toBe(150)
+		expect(re.timeSignatures.find(ts => ts.tick === 960)).toMatchObject({ numerator: 3, denominator: 4 })
+	})
+})
+
+describe('writeChartFile round-trip: [Events]', () => {
+	it('preserves sections at the right ticks with correct names', () => {
+		const chart = createEmptyChart()
+		chart.sections.push({ tick: 0, name: 'Intro', msTime: 0, msLength: 0 })
+		chart.sections.push({ tick: 1920, name: 'Verse 1', msTime: 0, msLength: 0 })
+		const re = roundTrip(chart)
+		expect(re.sections.map(s => ({ tick: s.tick, name: s.name }))).toEqual([
+			{ tick: 0, name: 'Intro' },
+			{ tick: 1920, name: 'Verse 1' },
+		])
+	})
+
+	it('preserves section names with special characters', () => {
+		const chart = createEmptyChart()
+		chart.sections.push({ tick: 0, name: '[BREAKDOWN]', msTime: 0, msLength: 0 })
+		expect(roundTrip(chart).sections[0].name).toBe('[BREAKDOWN]')
+	})
+
+	it('preserves end events', () => {
+		const chart = createEmptyChart()
+		chart.endEvents.push({ tick: 9600, msTime: 0, msLength: 0 })
+		expect(roundTrip(chart).endEvents.map(e => e.tick)).toEqual([9600])
+	})
+
+	it('preserves unrecognized global events', () => {
+		const chart = createEmptyChart({ format: 'chart' })
+		chart.unrecognizedEventsTrackTextEvents.push({ tick: 0, text: 'music_start', msTime: 0, msLength: 0 })
+		const re = roundTrip(chart)
+		expect(re.unrecognizedEventsTrackTextEvents.map(e => ({ tick: e.tick, text: e.text }))).toEqual([
+			{ tick: 0, text: 'music_start' },
+		])
+	})
+
+	it('does not duplicate an end event that also appears in unrecognizedEventsTrackTextEvents', () => {
+		const chart = createEmptyChart()
+		chart.endEvents.push({ tick: 1000, msTime: 0, msLength: 0 })
+		chart.unrecognizedEventsTrackTextEvents.push({ tick: 1000, text: 'end', msTime: 0, msLength: 0 })
+		const re = roundTrip(chart)
+		expect(re.endEvents.map(e => e.tick)).toEqual([1000])
+		expect(re.unrecognizedEventsTrackTextEvents.filter(e => e.text === 'end')).toHaveLength(0)
+	})
+})
+
+describe('writeChartFile round-trip: unrecognized chart sections', () => {
+	it('preserves unrecognized sections with arbitrary content', () => {
+		const chart = createEmptyChart()
+		chart.unrecognizedChartSections.push({
+			name: 'MysteryBlock',
+			lines: ['0 = foo', '100 = bar'],
+		})
+		expect(roundTrip(chart).unrecognizedChartSections).toEqual([
+			{ name: 'MysteryBlock', lines: ['0 = foo', '100 = bar'] },
+		])
+	})
+})
diff --git a/src/chart/chart-writer.ts b/src/chart/chart-writer.ts
new file mode 100644
index 0000000..6518d85
--- /dev/null
+++ b/src/chart/chart-writer.ts
@@ -0,0 +1,224 @@
+/**
+ * `.chart` file writer — serializes a ParsedChart back to chart text.
+ *
+ * This PR covers the non-instrument-track half of the writer:
+ * - `[Song]` section
+ * - `[SyncTrack]` section (tempo + time-signature events)
+ * - `[Events]` section (sections, endEvents, unrecognized global events,
+ *   vocal phrase/lyric events)
+ * - Pass-through of unrecognizedChartSections
+ *
+ * Instrument track emission (`[ExpertSingle]` etc.) lands in a follow-up PR.
+ */
+
+import type { ParsedChart } from './parse-chart-and-ini'
+
+/**
+ * Serialize a {@link ParsedChart} to `.chart` file text (CRLF line endings).
+ * Emits `[Song]`, `[SyncTrack]`, and `[Events]` sections plus any chart sections
+ * the parser didn't recognize (preserved verbatim for round-trip).
+ *
+ * Note: instrument track sections (`[ExpertSingle]`, `[HardDrums]`, etc.) are
+ * emitted by a follow-up PR. This entry point currently skips them.
+ */
+export function writeChartFile(chart: ParsedChart): string {
+	const sections: string[][] = []
+	sections.push(serializeSongSection(chart))
+	sections.push(serializeSyncTrack(chart))
+	sections.push(serializeEventsSection(chart))
+
+	// Re-emit any [Section] blocks the parser didn't recognize as standard
+	// (Song/SyncTrack/Events) or as a track section. Stored verbatim by
+	// scan-chart's unrecognizedChartSections fallback for round-trip preservation.
+	for (const us of chart.unrecognizedChartSections) {
+		const sec: string[] = [`[${us.name}]`, '{']
+		for (const ln of us.lines) sec.push(`  ${ln}`)
+		sec.push('}')
+		sections.push(sec)
+	}
+
+	// Flatten without using spread (which would exceed stack size on large arrays).
+	const out: string[] = []
+	for (const section of sections) {
+		for (const line of section) out.push(line)
+	}
+	return out.join('\r\n') + '\r\n'
+}
+
+// ---------------------------------------------------------------------------
+// [Song] section
+// ---------------------------------------------------------------------------
+
+/**
+ * The subset of `song.ini` fields that the `[Song]` section in a `.chart`
+ * file supports. Values for these fields in {@link ParsedChart.metadata} get
+ * re-emitted here; all other ini fields live exclusively in `song.ini`.
+ */
+function serializeSongSection(chart: ParsedChart): string[] {
+	const lines: string[] = ['[Song]', '{']
+	const m = chart.metadata
+
+	if (m.name != null) lines.push(`  Name = "${m.name}"`)
+	if (m.artist != null) lines.push(`  Artist = "${m.artist}"`)
+	if (m.charter != null) lines.push(`  Charter = "${m.charter}"`)
+	if (m.album != null) lines.push(`  Album = "${m.album}"`)
+	if (m.genre != null) lines.push(`  Genre = "${m.genre}"`)
+	// [Song]'s `Year` is historically written with a leading `, ` separator
+	// (a GHTCP quirk the scan-chart parser strips back out — see chart-parser).
+	if (m.year != null) lines.push(`  Year = ", ${m.year}"`)
+
+	lines.push(`  Resolution = ${chart.resolution}`)
+
+	// `[Song].Offset` is a .chart-only field — distinct from ini's `delay`,
+	// which games recognize only in song.ini. Read from `metadata.chart_offset`
+	// (populated by the parser from [Song].Offset) so that ini's `delay`
+	// never overrides it on the ini-wins merge. `PreviewStart` is seconds in
+	// the file, ms on ParsedChart.
+	if (m.chart_offset != null && m.chart_offset !== 0) {
+		lines.push(`  Offset = ${m.chart_offset / 1000}`)
+	}
+	if (m.preview_start_time != null) {
+		lines.push(`  PreviewStart = ${m.preview_start_time / 1000}`)
+	}
+	if (m.diff_guitar != null) lines.push(`  Difficulty = ${m.diff_guitar}`)
+
+	lines.push('}')
+	return lines
+}
+
+// ---------------------------------------------------------------------------
+// [SyncTrack] section
+// ---------------------------------------------------------------------------
+
+function serializeSyncTrack(chart: ParsedChart): string[] {
+	const lines: string[] = ['[SyncTrack]', '{']
+
+	type SyncEvent =
+		| { tick: number; order: 0; kind: 'ts'; numerator: number; denominator: number }
+		| { tick: number; order: 1; kind: 'bpm'; beatsPerMinute: number }
+
+	const events: SyncEvent[] = [
+		...chart.timeSignatures.map(
+			(ts): SyncEvent => ({
+				tick: ts.tick,
+				order: 0,
+				kind: 'ts',
+				numerator: ts.numerator,
+				denominator: ts.denominator,
+			}),
+		),
+		...chart.tempos.map(
+			(t): SyncEvent => ({ tick: t.tick, order: 1, kind: 'bpm', beatsPerMinute: t.beatsPerMinute }),
+		),
+	]
+
+	// Sort by tick, then TS before B at the same tick. Duplicates preserved.
+	events.sort((a, b) => {
+		if (a.tick !== b.tick) return a.tick - b.tick
+		return a.order - b.order
+	})
+
+	for (const ev of events) {
+		if (ev.kind === 'bpm') {
+			const millibeats = Math.round(ev.beatsPerMinute * 1000)
+			lines.push(`  ${ev.tick} = B ${millibeats}`)
+		} else if (ev.denominator === 4) {
+			lines.push(`  ${ev.tick} = TS ${ev.numerator}`)
+		} else {
+			lines.push(`  ${ev.tick} = TS ${ev.numerator} ${Math.log2(ev.denominator)}`)
+		}
+	}
+
+	lines.push('}')
+	return lines
+}
+
+// ---------------------------------------------------------------------------
+// [Events] section
+// ---------------------------------------------------------------------------
+
+function serializeEventsSection(chart: ParsedChart): string[] {
+	const lines: string[] = ['[Events]', '{']
+
+	// Typed events: sections (wrapped as `[section name]`), endEvents.
+	// Wrapping: scan-chart's section regex `^\[?(?:section|prc)[ _](.*?)\]?$`
+	// is greedy for the trailing `\]?$` and lazy for `(.*?)`, so an unwrapped
+	// `section [name]` would have its trailing `]` eaten as the optional
+	// closing bracket. Wrapping in outer brackets preserves the name.
+	const events: { tick: number; text: string }[] = []
+	for (const s of chart.sections) events.push({ tick: s.tick, text: `[section ${s.name}]` })
+	for (const e of chart.endEvents) events.push({ tick: e.tick, text: 'end' })
+
+	// Unrecognized global events (crowd events, music_start/end, coda, etc.).
+	// If the chart was originally parsed from .mid, these came in as `[text]`
+	// (square-bracketed MIDI text meta events) — strip the brackets so the
+	// .chart output writes the naked text between quotes (the .chart E-event
+	// convention).
+	const sourceIsMidi = chart.format === 'mid'
+	for (const ge of chart.unrecognizedEventsTrackTextEvents) {
+		let text = ge.text
+		if (sourceIsMidi) {
+			const trimmed = text.trimEnd()
+			if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+				text = trimmed.slice(1, -1)
+			}
+		}
+		// endEvents are already emitted above; skip duplicates here.
+		if (text.trim() === 'end') continue
+		events.push({ tick: ge.tick, text })
+	}
+
+	// Vocal phrases + lyrics from the normalized `vocals` part. .chart supports
+	// only one vocal track (harmonies are MIDI-only).
+	type TaggedEvent = { tick: number; text: string; subKey: number }
+	const eventPriority = (text: string): number => {
+		if (text === 'phrase_end') return 0
+		if (text.startsWith('lyric ')) return 1
+		if (text === 'coda') return 2
+		if (text.startsWith('section ')) return 3
+		if (text === 'phrase_start') return 4
+		if (text === 'end') return 5
+		return 4
+	}
+	const tagged: TaggedEvent[] = events.map(e => ({
+		tick: e.tick,
+		text: e.text,
+		subKey: 1_000_000 + eventPriority(e.text),
+	}))
+
+	const vocalsPart = chart.vocalTracks.parts.vocals
+	if (vocalsPart) {
+		// Emit phrase_start for every phrase. Omit phrase_end when the next
+		// phrase starts at exactly the same tick: the .chart parser closes the
+		// current phrase implicitly on the next phrase_start, so an explicit
+		// phrase_end would round-trip as a spurious duplicate.
+		const phrases = vocalsPart.notePhrases
+		for (let i = 0; i < phrases.length; i++) {
+			const phrase = phrases[i]
+			const endTick = phrase.tick + phrase.length
+			tagged.push({ tick: phrase.tick, text: 'phrase_start', subKey: i * 2 })
+			const next = phrases[i + 1]
+			const nextStartsAtOurEnd = next && next.tick === endTick
+			if (!nextStartsAtOurEnd) {
+				tagged.push({ tick: endTick, text: 'phrase_end', subKey: i * 2 + 1 })
+			}
+		}
+		for (const phrase of phrases) {
+			for (const lyric of phrase.lyrics) {
+				tagged.push({ tick: lyric.tick, text: `lyric ${lyric.text}`, subKey: 1_000_000 + 1 })
+			}
+		}
+	}
+
+	tagged.sort((a, b) => {
+		if (a.tick !== b.tick) return a.tick - b.tick
+		return a.subKey - b.subKey
+	})
+
+	for (const ev of tagged) {
+		lines.push(`  ${ev.tick} = E "${ev.text}"`)
+	}
+
+	lines.push('}')
+	return lines
+}
diff --git a/src/chart/index.ts b/src/chart/index.ts
index 23e5c25..4661673 100644
--- a/src/chart/index.ts
+++ b/src/chart/index.ts
@@ -1,3 +1,4 @@
 export * from './chart-scanner'
+export * from './chart-writer'
 export * from './create-chart'
 export * from './parse-chart-and-ini'