@hajimism/dek 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+Release notes for `@hajimism/dek`. From 0.1.0 on, release-please writes this file from the Conventional Commits on `main`.
+
+## [0.2.0](https://github.com/hajimism/dek/compare/v0.1.0...v0.2.0) (2026-10-01)
+
+
+### ⚠ BREAKING CHANGES
+
+* max_classes, cjk_per_minute and latin_per_minute in dek.toml no longer apply to existing decks. Add them to each deck's script.md frontmatter to keep them; lint's DEK008 names each one.
+
+### Features
+
+* let a deck own its class budget and speaking rate ([8dc9a07](https://github.com/hajimism/dek/commit/8dc9a07efb32b803e685a353ee628cae21a8bc56))
+
+
+### Bug Fixes
+
+* **lint:** count vbscript: and script-running data: URLs in DEK011 ([1b825b1](https://github.com/hajimism/dek/commit/1b825b1bffc33809ef0bdf3a8e5a1d45794a41a7))
+
+## 0.1.0 (2026-10-01)
+
+The first release on npm.
+
+### Features
+
+* Published as `@hajimism/dek`. Create a project with `bunx @hajimism/dek init`, then install it with `bun add -d @hajimism/dek`.
+
+### ⚠ BREAKING CHANGES
+
+* The command is `dekc`, not `dek`. `dek` on npm is an unrelated package, and `bunx dek` ran it anywhere dek was not installed. Run `bunx dekc` inside a project; the package, `dek.toml`, `.dek/`, and the `DEK` lint codes keep their names.

package/README.ja.md

@@ -1,5 +1,7 @@
 # dek
 
+[![npm](https://img.shields.io/npm/v/@hajimism/dek)](https://www.npmjs.com/package/@hajimism/dek) [![CI](https://github.com/hajimism/dek/actions/workflows/ci.yml/badge.svg)](https://github.com/hajimism/dek/actions/workflows/ci.yml) [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/hajimism/dek/badge)](https://scorecard.dev/viewer/?uri=github.com/hajimism/dek)
+
 **発表のビルドシステム。** 喋ることを書けば、あとは dek が組み立て、測り、届ける。
 
 [ドキュメント](https://hajimism.github.io/dek/ja/) · [English README](./README.md)
@@ -20,7 +22,7 @@ dek は、ビルドシステムがコードを扱うように発表を扱う CLI
 
 ## クイックスタート
 
-[Bun](https://bun.sh) 1.4 以上。
+[Bun](https://bun.sh) 1.4 以上が必要です。dek は Bun でだけ動き、Node では動きません。`npx` ではなく `bunx` を使ってください。
 
 ```bash
 bunx @hajimism/dek init my-talks --deck 2026-04-vite
@@ -66,10 +68,12 @@ bun run check             # Biome の format + lint
 bun run docs:dev          # VitePress
 ```
 
-CI では `biome ci`、`typecheck`、全テスト（ブラウザを使うものは Chromium で）、`docs:build` を走らせます。
+CI では `biome ci`、`typecheck`、`knip`、全テスト（ブラウザを使うものは Chromium で）、`docs:build`、`scripts/check-package.sh`（npm に出す tarball を入れて動かす）を走らせます。
 
 ドキュメントサイトは GitHub Actions 経由で GitHub Pages に出します。初回だけ、リポジトリの設定で **Pages → Source** を **GitHub Actions** にしてください。
 
+プルリクエストで通すチェックは [CONTRIBUTING.md](./CONTRIBUTING.md)、リリースごとの変更は [CHANGELOG.md](./CHANGELOG.md) にあります。脆弱性は [SECURITY.md](./SECURITY.md) のとおり非公開で報告してください。
+
 ## ライセンス
 
 MIT

package/README.md

@@ -1,5 +1,7 @@
 # dek
 
+[![npm](https://img.shields.io/npm/v/@hajimism/dek)](https://www.npmjs.com/package/@hajimism/dek) [![CI](https://github.com/hajimism/dek/actions/workflows/ci.yml/badge.svg)](https://github.com/hajimism/dek/actions/workflows/ci.yml) [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/hajimism/dek/badge)](https://scorecard.dev/viewer/?uri=github.com/hajimism/dek)
+
 **A build system for talks.** Write what you will say; dek builds, measures, and ships the rest.
 
 [Documentation](https://hajimism.github.io/dek/) · [日本語 README](./README.ja.md)
@@ -20,7 +22,7 @@ The three principles and the comparison with Slidev are in [Why dek](https://haj
 
 ## Quick start
 
-[Bun](https://bun.sh) 1.4 or later.
+Requires [Bun](https://bun.sh) 1.4 or later. dek runs on Bun only: it does not run on Node, so use `bunx`, not `npx`.
 
 ```bash
 bunx @hajimism/dek init my-talks --deck 2026-04-vite
@@ -66,10 +68,12 @@ bun run check             # Biome format + lint
 bun run docs:dev          # VitePress
 ```
 
-CI runs `biome ci`, `typecheck`, the full test suite (the browser tests in Chromium), and `docs:build`.
+CI runs `biome ci`, `typecheck`, `knip`, the full test suite (the browser tests in Chromium), `docs:build`, and `scripts/check-package.sh`, which installs the packed tarball and runs it.
 
 The documentation site deploys to GitHub Pages through Actions. Once, in the repository settings, set **Pages → Source** to **GitHub Actions**.
 
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for the checks a pull request runs, and [CHANGELOG.md](./CHANGELOG.md) for what each release changed. Report security issues privately, as [SECURITY.md](./SECURITY.md) describes.
+
 ## License
 
 MIT

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@hajimism/dek",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A build system for talks.",
   "license": "MIT",
+  "author": "Hajime Nakagawa (https://github.com/hajimism)",
   "type": "module",
   "bin": {
     "dekc": "src/cli.ts"
@@ -11,7 +12,8 @@
     "src",
     "LICENSE",
     "README.md",
-    "README.ja.md"
+    "README.ja.md",
+    "CHANGELOG.md"
   ],
   "repository": {
     "type": "git",
@@ -31,9 +33,12 @@
     "slides",
     "presentation",
     "talk",
+    "markdown",
     "build",
     "cli",
-    "html"
+    "html",
+    "bun",
+    "ai-agents"
   ],
   "scripts": {
     "test": "bun test --parallel=4",
@@ -61,5 +66,8 @@
     "playwright": "^1.63.0",
     "typescript": "^7.0.2",
     "vitepress": "^1.6.4"
+  },
+  "overrides": {
+    "vite": "^6.4.3"
   }
 }

package/src/cli/files.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { bundledTheme } from "../core/bundled-theme.ts";
+import type { DekConfig } from "../core/config.ts";
 import { deckPaths } from "../core/deck-paths.ts";
 import { DekError } from "../core/error.ts";
 import { walkUp } from "../core/optional.ts";
@@ -72,12 +73,17 @@ const INSTALL_DEK = "bun add -d @hajimism/dek";
  * shows sections, beats, and an estimate against the budget. A deck with a
  * voice starts in Japanese, the language dek's voice reads; any other in English.
  */
-export function defaultScript(title: string, lang: "en" | "ja" = "en"): string {
+export function defaultScript(
+  title: string,
+  lang: "en" | "ja" = "en",
+  settings: DekConfig["seed"] = {},
+): string {
+  const lines = Object.entries(settings).map(([key, value]) => `${key}: ${value}\n`);
   return `---
 # yaml-language-server: $schema=../../.dek/schema.json
 title: ${JSON.stringify(title)}
 duration: 1m
----
+${lines.join("")}---
 ${STARTER_BODY[lang]}`;
 }
 
@@ -230,18 +236,19 @@ function placeable(path: string, kind: "file" | "directory"): boolean {
 }
 
 /**
- * A deck's files: its directories, the starter script, the theme it starts
- * from, and voice settings when the project has a voice. The skeleton slides
- * are sync's to write, once the theme they are drawn in is in place.
+ * A new deck's files: its directories, the starter script, the theme it starts from, and what the
+ * project's dek.toml seeds, its deck settings and `[voice]`. From then on the deck owns them: a
+ * later change to dek.toml leaves it alone. The skeleton slides are sync's to write, once the
+ * theme they are drawn in is in place.
  */
 export function deckPlan(
   root: string,
   name: string,
   theme: string,
-  voice?: { engine: string; speaker: string; speed?: number },
+  { seed, voice }: Pick<DekConfig, "seed" | "voice"> = {},
 ): PlannedPath[] {
   const paths = deckPaths(join(root, "decks", name));
-  const script = defaultScript(name, voice ? "ja" : "en");
+  const script = defaultScript(name, voice ? "ja" : "en", seed);
   const plan: PlannedPath[] = [
     { path: paths.slides },
     { path: paths.assets },

package/src/cli/ls.ts

@@ -1,4 +1,3 @@
-import { type DekConfig, loadConfig } from "../core/config.ts";
 import type { Diagnostic } from "../core/diagnostic.ts";
 import { lintDeck, lintProject } from "../core/lint.ts";
 import { listSlides, type Project, type ProjectDeck } from "../core/resolve.ts";
@@ -54,7 +53,7 @@ export function lsCommand(target: DecksTarget): LsListResult | LsDeckResult {
   const { project, deck, ref } = target;
   if (deck && ref) {
     return {
-      ...formatDeck(deck, loadConfig(project.configPath), project, { lint: false }),
+      ...formatDeck(deck, project, { lint: false }),
       ...skippedChecks([
         { check: "lint", reason: "a ref is read-only; its problems are not yours to fix" },
       ]),
@@ -62,7 +61,7 @@ export function lsCommand(target: DecksTarget): LsListResult | LsDeckResult {
     };
   }
   if (deck) {
-    return formatDeck(deck, loadConfig(project.configPath), project);
+    return formatDeck(deck, project);
   }
   return {
     kind: "list",
@@ -85,11 +84,10 @@ function summarizeDeck(deck: ProjectDeck, project: Project): LsListResult["decks
 
 function formatDeck(
   deck: ProjectDeck,
-  config: DekConfig,
   project: Project,
   options: { lint: boolean } = { lint: true },
 ): LsDeckResult {
-  const timing = sectionTiming(deck.deck.sections, deck.deck.duration, config);
+  const timing = sectionTiming(deck.deck);
   const estimateTotal = timing.reduce((sum, row) => sum + row.estimateSeconds, 0);
   const timeline = tryLoadCachedTimeline(deck.dir);
 

package/src/cli/new.ts

@@ -48,8 +48,9 @@ export function newCommand(options: { cwd: string; name: string; themeFrom?: str
   }
 
   const theme = readFileSync(themeSource, "utf8");
-  const voice = loadConfig(project.configPath).voice;
-  const { created } = applyPlan(deckPlan(project.root, name, theme, voice));
+  const { created } = applyPlan(
+    deckPlan(project.root, name, theme, loadConfig(project.configPath)),
+  );
   // As sync would. AGENTS.md and .dek/ follow the project theme and dek, so they change here
   // only when either moved on since the last command that wrote them: say which.
   const synced = syncDeck(dir);

package/src/core/build.ts

@@ -49,7 +49,6 @@ export async function buildDeck(
     removeInside(imagePath, project.root);
   }
   const html = renderDeckDocument(deck, {
-    config,
     playerScript: options.playerScript,
     target: {
       kind: "build",

package/src/core/config.ts

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { z } from "zod";
 import { parsePublicUrl } from "./ogp.ts";
 import { isPinnedRev, isPlainRefName } from "./ref-name.ts";
+import { DeckSettings } from "./schema.ts";
 import { parseTomlWith } from "./zod.ts";
 
 export const Voice = z.object({
@@ -18,9 +19,7 @@ export const DekToml = z.object({
         "write the absolute http(s) URL dist/ is served from, like https://example.com/talks/",
     })
     .optional(),
-  max_classes: z.number().optional(),
-  cjk_per_minute: z.number().optional(),
-  latin_per_minute: z.number().optional(),
+  ...DeckSettings.partial().shape,
   voice: Voice.optional(),
   refs: z
     .record(z.string(), z.string())
@@ -49,20 +48,16 @@ type VoiceDefaults = {
 export type DekConfig = {
   /** Where dist/ is served from, ending in a slash; link previews need it for og:image. */
   url?: string;
-  maxClasses: number;
-  cjkPerMinute: number;
-  latinPerMinute: number;
+  /**
+   * The deck settings `dekc new` writes into a new deck's frontmatter. Nothing else reads them: a
+   * deck is judged by its own, so changing dek.toml leaves the decks already made as they were.
+   */
+  seed?: Partial<DeckSettings>;
   voice?: VoiceDefaults;
   /** `[refs]`: each ref name and the commit it is pinned to. */
   refs?: Record<string, string>;
 };
 
-export const DEFAULT_CONFIG: DekConfig = {
-  maxClasses: 40,
-  cjkPerMinute: 300,
-  latinPerMinute: 130,
-};
-
 export function parseDekToml(source: string, path?: string): DekConfig {
   const data = parseTomlWith(DekToml, source, {
     label: "dek.toml",
@@ -77,11 +72,10 @@ export function parseDekToml(source: string, path?: string): DekConfig {
       }
     : undefined;
   const url = data.url === undefined ? undefined : parsePublicUrl(data.url);
+  const seed = DeckSettings.partial().parse(data);
   return {
     ...(url ? { url } : {}),
-    maxClasses: data.max_classes ?? DEFAULT_CONFIG.maxClasses,
-    cjkPerMinute: data.cjk_per_minute ?? DEFAULT_CONFIG.cjkPerMinute,
-    latinPerMinute: data.latin_per_minute ?? DEFAULT_CONFIG.latinPerMinute,
+    ...(Object.keys(seed).length > 0 ? { seed } : {}),
     ...(voice ? { voice } : {}),
     ...(data.refs && Object.keys(data.refs).length > 0 ? { refs: data.refs } : {}),
   };
@@ -89,7 +83,7 @@ export function parseDekToml(source: string, path?: string): DekConfig {
 
 export function loadConfig(configPath: string): DekConfig {
   if (!existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG };
+    return {};
   }
   return parseDekToml(readFileSync(configPath, "utf8"), configPath);
 }

package/src/core/document.ts

@@ -1,6 +1,5 @@
 import { readTheme } from "./assets.ts";
 import { playerChromeCss } from "./chrome.ts";
-import { type DekConfig, loadConfig } from "./config.ts";
 import { escapeAttr, escapeHtml } from "./escape.ts";
 import { collectSlidesHtml, htmlShell } from "./html.ts";
 import { type OgpImage, ogpHead } from "./ogp.ts";
@@ -50,13 +49,12 @@ export function renderDeckHtml(
   dir: string,
   options: { playerScript: string; target: PageTarget },
 ): string {
-  const { project, deck } = resolveDeck(dir);
-  return renderDeckDocument(deck, { ...options, config: loadConfig(project.configPath) });
+  return renderDeckDocument(resolveDeck(dir).deck, options);
 }
 
 export function renderDeckDocument(
   deck: ProjectDeck,
-  options: { config: DekConfig; playerScript: string; target: PageTarget },
+  options: { playerScript: string; target: PageTarget },
 ): string {
   const { target } = options;
   const mode: PageMode =
@@ -69,7 +67,7 @@ export function renderDeckDocument(
   const standalone = !live;
   const strictScripts = target.kind === "video";
   const includeNotes = target.kind === "dev" ? target.includeNotes : target.kind === "build";
-  const data = presenterSlides(deck, options.config, scriptReader(target)).map((slide) =>
+  const data = presenterSlides(deck, scriptReader(target)).map((slide) =>
     includeNotes ? slide : { ...slide, script: "" },
   );
   const slidesHtml = collectSlidesHtml(deck, { inline: standalone });

package/src/core/lint/keys.ts

@@ -5,7 +5,9 @@ import {
   unknownTomlKeys,
 } from "../config-keys.ts";
 import { type Diagnostic, diag } from "../diagnostic.ts";
+import { readFrontmatterYaml } from "../parse.ts";
 import { type Project, readTextIfExists } from "../resolve.ts";
+import type { DeckSettings } from "../schema.ts";
 import type { LintContext } from "./context.ts";
 
 /*
@@ -21,10 +23,51 @@ export function tomlKeyDiagnostics(project: Project): Diagnostic[] {
 }
 
 /** DEK008 for the deck's frontmatter. */
-export function frontmatterKeyDiagnostics({ deck, script }: LintContext): Diagnostic[] {
-  return (script ? unknownFrontmatterKeys(script.yaml, 2) : []).map((key) =>
-    unknownKeyDiagnostic(key, { file: "frontmatter", path: deck.scriptPath }),
-  );
+export function frontmatterKeyDiagnostics(ctx: LintContext): Diagnostic[] {
+  const { deck, script } = ctx;
+  return [
+    ...(script ? unknownFrontmatterKeys(script.yaml, 2) : []).map((key) =>
+      unknownKeyDiagnostic(key, { file: "frontmatter", path: deck.scriptPath }),
+    ),
+    ...unfollowedSeedDiagnostics(ctx),
+  ];
+}
+
+/**
+ * DEK008 for a deck setting dek.toml sets and the deck leaves out. dek.toml only seeds `dekc new`,
+ * so a deck made before it, or without the key, keeps the default: said where the key would go,
+ * and only when the two differ, since otherwise the verdict is the same either way.
+ */
+function unfollowedSeedDiagnostics({ config, deck, script }: LintContext): Diagnostic[] {
+  if (!script || !config.seed) {
+    return [];
+  }
+  const written = readFrontmatterKeys(script.yaml);
+  return Object.entries(config.seed).flatMap(([key, value]) => {
+    const used = deck.deck[key as keyof DeckSettings];
+    if (written.has(key) || value === used) {
+      return [];
+    }
+    return [
+      diag("DEK008", {
+        message: `dek.toml sets ${key} = ${value}, which this deck does not follow; it uses ${used}`,
+        path: deck.scriptPath,
+        line: script.bodyStartLine - 1,
+        hint: `to keep ${value}, add \`${key}: ${value}\` to the frontmatter; dek.toml only seeds \`dekc new\``,
+        data: { file: "frontmatter", key, value },
+      }),
+    ];
+  });
+}
+
+/** The top-level keys the frontmatter writes; none when its YAML does not parse. */
+function readFrontmatterKeys(yaml: string): Set<string> {
+  try {
+    const parsed = readFrontmatterYaml(yaml);
+    return new Set(parsed && typeof parsed === "object" ? Object.keys(parsed) : []);
+  } catch {
+    return new Set();
+  }
 }
 
 function unknownKeyDiagnostic(

package/src/core/lint/slide-html.ts

@@ -272,7 +272,7 @@ function morphDiagnostics({ section, path, scan }: SlideHtml): Diagnostic[] {
 /**
  * DEK011: style or script inside the markup, which belongs in the slide's own .css or .ts. Every
  * occurrence is its own finding: a `<style>` or `<script>` element, a `style` attribute, an event
- * handler attribute, and a `javascript:` URL.
+ * handler attribute, and a URL that runs script.
  */
 function inlineCodeDiagnostics({ section, path, scan }: SlideHtml): Diagnostic[] {
   return scan.elements
@@ -346,8 +346,11 @@ function inlineAttribute(
       hint: `remove it; a slide takes no input, and motion goes in slides/${slug}.ts as a draw(t) function`,
     };
   }
-  if (isUrlAttribute(tag, attribute.name) && isJavascriptUrl(attribute.value)) {
-    return { message: "slide contains a javascript: URL", hint: motionHint(slug) };
+  const scheme = isUrlAttribute(tag, attribute.name)
+    ? scriptUrlScheme(tag, attribute.value)
+    : undefined;
+  if (scheme) {
+    return { message: `slide contains a ${scheme} URL`, hint: motionHint(slug) };
   }
   return undefined;
 }
@@ -358,13 +361,34 @@ function motionHint(slug: string): string {
 
 /** `onclick`, `onload`, and every other attribute the browser runs as script. */
 const EVENT_HANDLER_RE = /^on[a-z]+$/;
-/** Read the way the URL parser reads it: tabs and newlines dropped, leading space trimmed, any case. */
-function isJavascriptUrl(value: string): boolean {
-  return value
+/** Tags that load a URL as a document of its own, so an SVG there runs its scripts. */
+const DOCUMENT_TAGS = new Set(["iframe", "frame", "object", "embed"]);
+
+/**
+ * The scheme of a URL that runs script, or undefined: `javascript:` and `vbscript:` always, and a
+ * `data:` URL holding HTML, or SVG where a tag loads it as a document. An image's `data:` stays.
+ * Read the way the URL parser reads it: tabs and newlines dropped, leading space trimmed, any case.
+ */
+function scriptUrlScheme(tag: string, value: string): string | undefined {
+  const url = value
     .replace(/[\t\n\r]/g, "")
     .trimStart()
-    .toLowerCase()
-    .startsWith("javascript:");
+    .toLowerCase();
+  if (url.startsWith("javascript:")) {
+    return "javascript:";
+  }
+  if (url.startsWith("vbscript:")) {
+    return "vbscript:";
+  }
+  if (url.startsWith("data:")) {
+    const type = url.slice("data:".length).split(/[;,]/, 1)[0]?.trim();
+    const runs =
+      type === "text/html" ||
+      type === "application/xhtml+xml" ||
+      (type === "image/svg+xml" && DOCUMENT_TAGS.has(tag));
+    return runs ? "data:" : undefined;
+  }
+  return undefined;
 }
 
 /**

package/src/core/lint/theme-css.ts

@@ -290,6 +290,6 @@ function themeScopeHint(selector: string): string {
 /** The theme's own findings, or DEK018 when there is no theme. */
 export function themeDiagnostics(ctx: LintContext): Diagnostic[] {
   return ctx.theme
-    ? lintTheme(ctx.theme, { maxClasses: ctx.config.maxClasses, deckDir: ctx.deck.dir })
+    ? lintTheme(ctx.theme, { maxClasses: ctx.deck.deck.max_classes, deckDir: ctx.deck.dir })
     : [missingThemeDiagnostic(ctx)];
 }

package/src/core/lint/timing.ts

@@ -1,4 +1,3 @@
-import type { DekConfig } from "../config.ts";
 import { type Diagnostic, diag } from "../diagnostic.ts";
 import type { ProjectDeck } from "../resolve.ts";
 import type { Timeline } from "../timeline.ts";
@@ -13,7 +12,7 @@ const ESTIMATE_DRIFT_RATIO = 0.35;
 /** DEK041 against the voice timeline when there is one, else against the reading-time estimate. */
 export function timingDiagnostics(ctx: LintContext): Diagnostic[] {
   const timeline = tryLoadCachedTimeline(ctx.deck.dir);
-  return timeline ? lintDuration(ctx.deck, timeline) : lintEstimate(ctx.deck, ctx.config);
+  return timeline ? lintDuration(ctx.deck, timeline) : lintEstimate(ctx.deck);
 }
 
 function lintDuration(deck: ProjectDeck, timeline: Timeline): Diagnostic[] {
@@ -37,15 +36,12 @@ function lintDuration(deck: ProjectDeck, timeline: Timeline): Diagnostic[] {
 }
 
 /** DEK041 before any voice: the reading-time estimate `dekc ls` shows, against the budget. */
-function lintEstimate(deck: ProjectDeck, config: DekConfig): Diagnostic[] {
+function lintEstimate(deck: ProjectDeck): Diagnostic[] {
   const budget = parseDurationSeconds(deck.deck.duration);
   if (budget === undefined || budget <= 0) {
     return [];
   }
-  const estimate = sectionTiming(deck.deck.sections, deck.deck.duration, config).reduce(
-    (sum, row) => sum + row.estimateSeconds,
-    0,
-  );
+  const estimate = sectionTiming(deck.deck).reduce((sum, row) => sum + row.estimateSeconds, 0);
   if (Math.abs(estimate - budget) / budget < ESTIMATE_DRIFT_RATIO) {
     return [];
   }

package/src/core/presenter.ts

@@ -1,4 +1,3 @@
-import type { DekConfig } from "./config.ts";
 import type { PresenterSlide } from "./presenter-state.ts";
 import type { ProjectDeck } from "./resolve.ts";
 import { type ScriptLine, scriptLines } from "./script-lines.ts";
@@ -18,10 +17,9 @@ export type ScriptReader = "speaker" | "audience";
 
 export function presenterSlides(
   deck: ProjectDeck,
-  config: DekConfig,
   reader: ScriptReader = "speaker",
 ): PresenterSlide[] {
-  const timing = sectionTiming(deck.deck.sections, deck.deck.duration, config);
+  const timing = sectionTiming(deck.deck);
   const budgetBySlug = new Map(timing.map((row) => [row.slug, row.budgetSeconds]));
   return deck.deck.sections.map((section) => {
     const script = formatSectionScript(section);

package/src/core/schema.ts

@@ -52,6 +52,25 @@ export function inferLang(text: string): string {
   return "en";
 }
 
+/**
+ * How a deck is judged: the theme's class budget and the speaking rate the estimate reads. A deck
+ * owns them in its frontmatter, so a project that changes later leaves a finished talk as it was;
+ * dek.toml may set the same keys, and `dekc new` copies them into the deck it makes.
+ */
+export const DeckSettings = z.object({
+  max_classes: z.number().describe("The most classes theme.css may define (DEK013)."),
+  cjk_per_minute: z.number().describe("Speaking rate for CJK text, in characters a minute."),
+  latin_per_minute: z.number().describe("Speaking rate for other text, in words a minute."),
+});
+
+export type DeckSettings = z.infer<typeof DeckSettings>;
+
+export const DECK_SETTING_DEFAULTS: DeckSettings = {
+  max_classes: 40,
+  cjk_per_minute: 300,
+  latin_per_minute: 130,
+};
+
 /** Frontmatter fields written to `.dek/schema.json` for yaml-language-server. */
 export const Frontmatter = z.object({
   title: z.string(),
@@ -69,6 +88,11 @@ export const Frontmatter = z.object({
   lang: Lang.optional().describe(
     "BCP 47 tag for the page. Omit it to follow the script: kana → ja, Hangul → ko, Han → zh, else en.",
   ),
+  max_classes: DeckSettings.shape.max_classes.default(DECK_SETTING_DEFAULTS.max_classes),
+  cjk_per_minute: DeckSettings.shape.cjk_per_minute.default(DECK_SETTING_DEFAULTS.cjk_per_minute),
+  latin_per_minute: DeckSettings.shape.latin_per_minute.default(
+    DECK_SETTING_DEFAULTS.latin_per_minute,
+  ),
 });
 
 export type Frontmatter = z.infer<typeof Frontmatter>;

package/src/core/sync.ts

@@ -252,7 +252,7 @@ A build system for talks. Write what you will say; dek builds, measures, and shi
 - One \`##\` heading is one slide. HTML lives in \`slides/<id>.html\`.
 - Each deck owns its \`theme.css\`. Before writing a slide, run \`dekc theme\` in the deck for the classes, tokens, and layouts it defines, and \`dekc theme <layout>\` for a layout's markup.
 - Shared look lives in \`theme.css\`. Decoration only one slide uses lives in \`slides/<id>.css\`, which is scoped to that slide.
-- Use only classes defined in \`theme.css\` or in that slide's own \`slides/<id>.css\`. The theme holds at most \`max_classes\` in \`dek.toml\`, 40 by default (\`DEK013\`); classes in \`slides/<id>.css\` do not count, so keep a class only one slide uses there.
+- Use only classes defined in \`theme.css\` or in that slide's own \`slides/<id>.css\`. The theme holds at most \`max_classes\` in the frontmatter of \`script.md\`, 40 by default (\`DEK013\`); classes in \`slides/<id>.css\` do not count, so keep a class only one slide uses there.
 - A rule in \`slides/<id>.css\` weighs as if it were written at the end of \`theme.css\`: it beats the theme's \`.slide .x\`, but not a more specific rule such as a layout's \`.slide[data-layout="split"] .x\` or the beat state \`.slide.is-current [data-step]\`. To override one of those, write the same selector.
 - Color, type, space, radius, and motion in either stylesheet use token \`var()\` only. A value only one slide uses can be a token of its own on that slide's \`.slide\` rule in \`slides/<id>.css\`.
 - Do not add \`<style>\`, \`style=\`, \`<script>\`, event handler attributes (\`onclick=\` and the like), or \`javascript:\` URLs inside slide HTML.

package/src/core/timing.ts

@@ -1,4 +1,4 @@
-import type { DekConfig } from "./config.ts";
+import type { Deck } from "./schema.ts";
 
 type SectionBodies = {
   body: string;
@@ -28,14 +28,23 @@ function speechChars(text: string): number {
   return stripBlockquotes(text).replace(/\s+/g, "").length;
 }
 
-function estimateSeconds(text: string, config: DekConfig): number {
+/** The rate a deck is spoken at, from its own frontmatter. */
+type SpeakingRate = Pick<Deck, "cjk_per_minute" | "latin_per_minute">;
+
+/** What timing reads of a deck: its sections, its budget, and the rate it is spoken at. */
+type TimedDeck = SpeakingRate & {
+  sections: Array<{ slug: string } & SectionBodies>;
+  duration?: string | undefined;
+};
+
+function estimateSeconds(text: string, rate: SpeakingRate): number {
   const stripped = stripBlockquotes(text);
   const cjk = [...stripped.matchAll(/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/gu)]
     .length;
   const rest = stripped.replace(/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/gu, " ");
   const words = rest.split(/\s+/).filter(Boolean).length;
-  const cjkMinutes = config.cjkPerMinute > 0 ? cjk / config.cjkPerMinute : 0;
-  const latinMinutes = config.latinPerMinute > 0 ? words / config.latinPerMinute : 0;
+  const cjkMinutes = rate.cjk_per_minute > 0 ? cjk / rate.cjk_per_minute : 0;
+  const latinMinutes = rate.latin_per_minute > 0 ? words / rate.latin_per_minute : 0;
   return Math.round((cjkMinutes + latinMinutes) * 60);
 }
 
@@ -62,21 +71,17 @@ export type TimedSection = {
   budgetSeconds?: number;
 };
 
-export function sectionTiming(
-  sections: Array<{ slug: string; body: string; beats: Array<{ body: string }> }>,
-  duration: string | undefined,
-  config: DekConfig,
-): TimedSection[] {
-  const rows = sections.map((section) => {
+export function sectionTiming(deck: TimedDeck): TimedSection[] {
+  const rows = deck.sections.map((section) => {
     const text = speechText(section);
     return {
       slug: section.slug,
       chars: speechChars(text),
-      estimateSeconds: estimateSeconds(text, config),
+      estimateSeconds: estimateSeconds(text, deck),
     };
   });
   const totalChars = rows.reduce((sum, row) => sum + row.chars, 0);
-  const durationSeconds = parseDurationSeconds(duration);
+  const durationSeconds = parseDurationSeconds(deck.duration);
 
   return rows.map((row) => ({
     slug: row.slug,

package/src/core/video-document.ts

@@ -1,4 +1,3 @@
-import { loadConfig } from "./config.ts";
 import { renderDeckDocument } from "./document.ts";
 import type { ResolvedDeck } from "./resolve.ts";
 
@@ -6,9 +5,8 @@ import type { ResolvedDeck } from "./resolve.ts";
  * The whole deck as `dekc video` plays it: every slide, assets inlined, no notes, and the player
  * runtime that walks it. Motion stills, morph frames and the video itself all run on this page.
  */
-export function videoDocument({ project, deck }: ResolvedDeck, playerScript: string): string {
+export function videoDocument({ deck }: ResolvedDeck, playerScript: string): string {
   return renderDeckDocument(deck, {
-    config: loadConfig(project.configPath),
     playerScript,
     target: { kind: "video" },
   });