Fix dev-mode build failures, add CI, commit the missing slide-ID module

`pnpm dev` printed build errors that `pnpm build` never showed, because
`pnpm -r build` is topologically ordered while `pnpm -r --parallel dev`
discards that ordering:

- workers/og-preview is the only workspace member without a source alias,
  so esbuild resolves core through package.json exports to dist/index.js.
  Core's watch build emptied dist/ on every rebuild, and the worker failed
  against the empty window before recovering. Core now only cleans dist/
  for a real build.
- player's dts pass uses rollupTypes (api-extractor), which intermittently
  fails on incremental rebuilds. Declarations are now emitted only for a
  real build — nothing in dev reads them, since every app aliases core and
  player to src/.

While in there: core's `tsc -p tsconfig.build.json` step emitted nothing at
all. tsconfig.base.json sets noEmit, which overrode its emitDeclarationOnly,
and tsc exits 0 having done nothing — so vite-plugin-dts was the sole emitter
and its unscoped include shipped dist/**/*.test.d.ts to npm. Dropped the dead
step and its config, scoped the plugin to exclude tests.

Also adds `dev:og` for the core/embed/worker subset, so the common case
doesn't need all ten dev processes.

packages/core/src/adapters/ids.ts and its test were never staged, though
81f1e5f committed every caller — a clean checkout could not build. The new
CI workflow builds, typechecks and tests a fresh checkout on push and PR;
publish.yml only ran on release tags, which is why this went unnoticed.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: JoeGermuska

.github/workflows/ci.yml

@@ -0,0 +1,40 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+# A newer push to the same branch or PR makes an in-flight run irrelevant.
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: pnpm/action-setup@v6
+        with:
+          version: 11
+
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 22
+          cache: pnpm
+
+      - run: pnpm install --frozen-lockfile
+
+      - run: pnpm typecheck
+
+      - run: pnpm test:run
+
+      # Last because it is the slowest, but the reason this workflow exists:
+      # it builds a clean checkout, so a source file that was never committed
+      # fails here instead of during a release tag.
+      - run: pnpm build

package.json

@@ -7,6 +7,7 @@
     "test": "pnpm -r test",
     "test:run": "pnpm -r test:run",
     "dev": "pnpm -r --parallel dev",
+    "dev:og": "pnpm --parallel --filter @knight-lab/timeline-ng-core --filter @timeline-ng/embed --filter @timeline-ng/og-preview dev",
     "authoring": "pnpm --filter @timeline-ng/authoring dev",
     "authoring:devnet": "pnpm --filter @timeline-ng/authoring dev:devnet",
     "embed": "pnpm --filter @timeline-ng/embed dev",

packages/core/CHANGELOG.md

@@ -23,6 +23,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
   and unique — so a timeline-ng file round-trips unchanged — and rebuilds the
   rest the same way. Title slides get `title`. Duplicates are suffixed `-2`, `-3`.
 
+### Fixed
+
+- **Declarations for test files no longer ship.** The published tarball included
+  `dist/**/*.test.d.ts`, because declaration generation ran over all of `src`.
+  Only the public surface is emitted now.
+
 ## [0.4.0] - 2026-08-25
 
 ### Added

packages/core/package.json

@@ -29,7 +29,7 @@
     "schema"
   ],
   "scripts": {
-    "build": "vite build && tsc -p tsconfig.build.json && node scripts/schema.mjs",
+    "build": "vite build && node scripts/schema.mjs",
     "build:schema": "node scripts/schema.mjs",
     "dev": "vite build --watch",
     "test": "vitest",

packages/core/src/adapters/ids.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect } from 'vitest';
+import { slugifySlideId, isValidSlideId, uniqueSlideId, assignSlideIds } from './ids.ts';
+import type { TLTimeline } from '../types.ts';
+
+describe('slugifySlideId', () => {
+  it('slugs a headline', () => {
+    expect(slugifySlideId('The Moon Landing')).toBe('the-moon-landing');
+  });
+
+  it('strips HTML and punctuation', () => {
+    expect(slugifySlideId('<b>Apollo 11:</b> "one small step"')).toBe('apollo-11-one-small-step');
+  });
+
+  it('folds accents rather than dropping the word', () => {
+    expect(slugifySlideId('Año Nuevo en México')).toBe('ano-nuevo-en-mexico');
+  });
+
+  it('keeps a leading number by prefixing instead of truncating', () => {
+    expect(slugifySlideId('1969 Moon Landing')).toBe('slide-1969-moon-landing');
+  });
+
+  it('returns empty when nothing usable survives', () => {
+    expect(slugifySlideId('???')).toBe('');
+    expect(slugifySlideId('東京')).toBe('');
+  });
+
+  it('produces legal ids', () => {
+    for (const h of ['The Moon Landing', '1969 Moon Landing', '<b>Apollo 11:</b>']) {
+      expect(isValidSlideId(slugifySlideId(h))).toBe(true);
+    }
+  });
+});
+
+describe('assignSlideIds', () => {
+  it('builds ids from headlines', () => {
+    const tl: TLTimeline = {
+      events: [
+        { start_date: { year: 2000 }, text: { headline: 'First Thing' } },
+        { start_date: { year: 2001 }, text: { headline: 'Second Thing' } },
+      ],
+    };
+    assignSlideIds(tl);
+    expect(tl.events.map(e => e.unique_id)).toEqual(['first-thing', 'second-thing']);
+  });
+
+  it('replaces illegal ids, including the numeric ones legacy imports produced', () => {
+    const tl: TLTimeline = {
+      events: [
+        { start_date: { year: 2000 }, unique_id: '1', text: { headline: 'First Thing' } },
+        { start_date: { year: 2001 }, unique_id: '2', text: { headline: 'Second Thing' } },
+      ],
+    };
+    assignSlideIds(tl);
+    expect(tl.events.map(e => e.unique_id)).toEqual(['first-thing', 'second-thing']);
+  });
+
+  it('keeps ids that are already legal', () => {
+    const tl: TLTimeline = {
+      events: [{ start_date: { year: 2000 }, unique_id: 'my-slide', text: { headline: 'First Thing' } }],
+    };
+    assignSlideIds(tl);
+    expect(tl.events[0].unique_id).toBe('my-slide');
+  });
+
+  it('names the title slide "title"', () => {
+    const tl: TLTimeline = { title: { unique_id: '1', text: { headline: 'My Timeline' } }, events: [] };
+    assignSlideIds(tl);
+    expect(tl.title?.unique_id).toBe('title');
+  });
+
+  it('disambiguates repeated headlines', () => {
+    const tl: TLTimeline = {
+      events: [
+        { start_date: { year: 2000 }, text: { headline: 'Same' } },
+        { start_date: { year: 2001 }, text: { headline: 'Same' } },
+        { start_date: { year: 2002 }, text: { headline: 'Same' } },
+      ],
+    };
+    assignSlideIds(tl);
+    expect(tl.events.map(e => e.unique_id)).toEqual(['same', 'same-2', 'same-3']);
+  });
+
+  it('does not let a regenerated id collide with a preserved one', () => {
+    const tl: TLTimeline = {
+      events: [
+        { start_date: { year: 2000 }, unique_id: '1', text: { headline: 'Same' } },
+        { start_date: { year: 2001 }, unique_id: 'same', text: { headline: 'Same' } },
+      ],
+    };
+    assignSlideIds(tl);
+    expect(tl.events.map(e => e.unique_id)).toEqual(['same-2', 'same']);
+  });
+
+  it('falls back to a positional id when a headline yields nothing', () => {
+    const tl: TLTimeline = {
+      events: [
+        { start_date: { year: 2000 } },
+        { start_date: { year: 2001 }, text: { headline: '東京' } },
+      ],
+    };
+    assignSlideIds(tl);
+    expect(tl.events.map(e => e.unique_id)).toEqual(['slide-1', 'slide-2']);
+    for (const e of tl.events) expect(isValidSlideId(e.unique_id!)).toBe(true);
+  });
+
+  it('gives every event an id even with duplicate illegal ids in the source', () => {
+    const tl: TLTimeline = {
+      events: [
+        { start_date: { year: 2000 }, unique_id: 'dup', text: { headline: 'A' } },
+        { start_date: { year: 2001 }, unique_id: 'dup', text: { headline: 'B' } },
+      ],
+    };
+    assignSlideIds(tl);
+    expect(tl.events.map(e => e.unique_id)).toEqual(['dup', 'b']);
+  });
+});
+
+describe('uniqueSlideId', () => {
+  it('returns the base when it is free', () => {
+    expect(uniqueSlideId('intro', new Set(['other']))).toBe('intro');
+  });
+
+  it('suffixes past every taken variant', () => {
+    expect(uniqueSlideId('intro', new Set(['intro', 'intro-2']))).toBe('intro-3');
+  });
+
+  it('does not mutate the set it is given', () => {
+    const taken = new Set(['intro']);
+    uniqueSlideId('intro', taken);
+    expect([...taken]).toEqual(['intro']);
+  });
+});
+
+describe('slugifySlideId with entities', () => {
+  it('drops HTML entities rather than spelling them out', () => {
+    expect(slugifySlideId('Rock &amp; Roll')).toBe('rock-roll');
+  });
+});

packages/core/src/adapters/ids.ts

@@ -0,0 +1,86 @@
+import type { TLEvent, TLTimeline } from '../types.ts';
+
+/**
+ * The shape a slide ID has to have: a letter, then letters, digits, `-` or `_`.
+ *
+ * Slide IDs are meant to be usable as URL fragments and CSS/DOM identifiers,
+ * so the rule is deliberately narrower than "any non-empty string".
+ */
+export const SLIDE_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+
+export function isValidSlideId(id: string): boolean {
+  return SLIDE_ID_PATTERN.test(id);
+}
+
+/** Slugs longer than this get cut — long enough to stay readable, short enough to type. */
+const MAX_SLUG_LENGTH = 48;
+
+/**
+ * Turn arbitrary headline text into the longest legal ID it can support.
+ * Returns '' when nothing usable survives (a headline that is entirely
+ * punctuation, or entirely in a script with no ASCII transliteration).
+ */
+export function slugifySlideId(text: string): string {
+  const slug = text
+    .replace(/<[^>]*>/g, ' ')          // headlines may carry HTML
+    .replace(/&(?:[a-zA-Z][a-zA-Z0-9]*|#\d+|#x[0-9a-fA-F]+);/g, ' ')  // …and entities
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')       // é → e, ñ → n
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, MAX_SLUG_LENGTH)
+    .replace(/-+$/, '');
+  if (!slug) return '';
+  // A leading digit is illegal, but dropping it would lose real information
+  // ("1969 Moon Landing"), so prefix instead of truncate.
+  return /^[a-z]/.test(slug) ? slug : `slide-${slug}`;
+}
+
+/**
+ * `base` if it is free, else `base-2`, `base-3`, … until one is.
+ * Non-mutating, so callers that only need to *offer* an ID (the editor's
+ * "generate from the headline" affordance) can use it too.
+ */
+export function uniqueSlideId(base: string, taken: ReadonlySet<string>): string {
+  if (!taken.has(base)) return base;
+  for (let n = 2; ; n++) {
+    const candidate = `${base}-${n}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+}
+
+/** Claim `base` in `taken`, appending -2, -3, … until it is free. */
+function claim(base: string, taken: Set<string>): string {
+  const id = uniqueSlideId(base, taken);
+  taken.add(id);
+  return id;
+}
+
+/**
+ * Give every event in an imported timeline a legal, unique slide ID, in place.
+ *
+ * IDs already present in the source are kept when they are legal and unique —
+ * an author who set `unique_id` deliberately, or a timeline-ng file being read
+ * back in, should round-trip unchanged. Everything else is regenerated from the
+ * headline, which is what makes an imported timeline's IDs worth looking at:
+ * TimelineJS 3's spreadsheet format has no ID column at all, so a sheet import
+ * would otherwise arrive as 1..N, which is both meaningless and illegal.
+ */
+export function assignSlideIds(timeline: TLTimeline): void {
+  const all: TLEvent[] = timeline.title ? [timeline.title, ...timeline.events] : timeline.events;
+  const taken = new Set<string>();
+
+  for (const event of all) {
+    const id = event.unique_id;
+    if (id && isValidSlideId(id) && !taken.has(id)) taken.add(id);
+    else delete event.unique_id;
+  }
+
+  all.forEach((event, i) => {
+    if (event.unique_id) return;
+    const isTitle = event === timeline.title;
+    const base = (isTitle ? 'title' : slugifySlideId(event.text?.headline ?? '')) || `slide-${i + 1}`;
+    event.unique_id = claim(base, taken);
+  });
+}

packages/core/tsconfig.build.json

@@ -1,11 +1,26 @@
 import { defineConfig } from 'vite';
 import dts from 'vite-plugin-dts';
 
+// `pnpm dev` runs this as `vite build --watch`. Nothing in dev reads dist/ —
+// every app aliases this package to src/ — so declarations are pure cost there,
+// and clearing dist/ between rebuilds actively breaks workers/og-preview, which
+// resolves us through package.json exports rather than an alias.
+const watching = process.argv.includes('--watch') || process.argv.includes('-w');
+
 export default defineConfig({
   plugins: [
-    dts({ include: ['src'], insertTypesEntry: true }),
+    // This is the only thing that emits declarations for this package; the
+    // `tsc -p tsconfig.build.json` step the build script used to run was a
+    // silent no-op, because tsconfig.base.json's `noEmit` overrode its
+    // `emitDeclarationOnly`. Tests need excluding here or they ship.
+    ...(watching ? [] : [dts({
+      include: ['src'],
+      exclude: ['src/**/*.test.ts'],
+      insertTypesEntry: true,
+    })]),
   ],
   build: {
+    emptyOutDir: !watching,
     lib: {
       entry: 'src/index.ts',
       formats: ['es', 'cjs'],

packages/core/vite.config.ts

@@ -3,6 +3,11 @@ import { svelte } from '@sveltejs/vite-plugin-svelte';
 import dts from 'vite-plugin-dts';
 import { resolve } from 'path';
 
+// `pnpm dev` runs this as `vite build --watch`. Nothing in dev reads dist/*.d.ts
+// — every app aliases this package to src/ — and rollupTypes (api-extractor)
+// intermittently fails on incremental rebuilds, so only emit types for a real build.
+const watching = process.argv.includes('--watch') || process.argv.includes('-w');
+
 export default defineConfig({
   resolve: {
     alias: {
@@ -12,7 +17,7 @@ export default defineConfig({
   },
   plugins: [
     svelte(),
-    dts({
+    ...(watching ? [] : [dts({
       include: ['src'],
       insertTypesEntry: true,
       rollupTypes: true,
@@ -23,7 +28,7 @@ export default defineConfig({
           `from '@knight-lab/timeline-ng-core'`
         ),
       }),
-    }),
+    })]),
   ],
   build: {
     lib: {