@hajimism/dek 0.3.2 → 0.4.0

package/src/core/zod.ts

@@ -1,5 +1,6 @@
 import type { z } from "zod";
 import { DekError } from "./error.ts";
+import { isPlainWord } from "./escape.ts";
 
 const REFERENCE = "https://hajimism.github.io/dek/reference/config.html";
 
@@ -21,10 +22,17 @@ export function parseFailure(error: unknown): string {
   );
 }
 
+/**
+ * Each issue as `path: message`. A key in the path is the file's text, which a cloned project or
+ * a pack brings along, so one that is no plain word shows as `<key>`: repeated, it could close a
+ * code span or start a line of its own.
+ */
 export function formatZodIssues(error: z.ZodError): string {
   return error.issues
     .map((issue) => {
-      const path = issue.path.join(".");
+      const path = issue.path
+        .map((key) => (isPlainWord(String(key)) ? String(key) : "<key>"))
+        .join(".");
       // "expected string, received undefined" says less than "required".
       const message =
         issue.code === "invalid_type" && /received undefined$/.test(issue.message)

package/src/runtime/annotate-view.ts

@@ -671,10 +671,12 @@ export function createAnnotateView(options: {
       return;
     }
     event.stopPropagation();
-    if (event.target !== field) {
+    // Safari sends the key that commits or cancels a conversion after compositionend, with
+    // isComposing false; keyCode 229 still marks it as the input method's.
+    if (event.target !== field || event.isComposing || event.keyCode === 229) {
       return;
     }
-    if (event.key === "Enter" && !event.shiftKey && !event.isComposing) {
+    if (event.key === "Enter" && !event.shiftKey) {
       event.preventDefault();
       submit();
     } else if (event.key === "Escape") {

package/src/server/dev.ts

@@ -1,7 +1,8 @@
 import { join } from "node:path";
 import { DekError } from "../core/error.ts";
 import type { PlaywrightRunner } from "../core/playwright.ts";
-import { locateDeck, type Project, resolveProject } from "../core/resolve.ts";
+import { isRefName, refReadOnlyError, requireProject } from "../core/ref.ts";
+import { locateDeck, type Project } from "../core/resolve.ts";
 import { annotateScript, livePlayerScript, liveReloadScript } from "../runtime/player.ts";
 import {
   clearance,
@@ -13,7 +14,12 @@ import {
 } from "./auth.ts";
 import type { EventFeed } from "./hub.ts";
 import { generateRemotePassword, lanUrls } from "./lan.ts";
-import { assertNoDevServer, removeDevServerLock, writeDevServerLock } from "./lock.ts";
+import {
+  assertNoDevServer,
+  devServerUrl,
+  removeDevServerLock,
+  writeDevServerLock,
+} from "./lock.ts";
 import { createDevPages } from "./pages.ts";
 import { createPairings, type Pairings } from "./pairing.ts";
 import { createProjectWatch } from "./project-watch.ts";
@@ -63,7 +69,12 @@ type Access = {
 type ServedRoutes = Omit<RouteContext, "upgrade">;
 
 export async function startDevServer(options: DevServerOptions): Promise<DevServer> {
-  const project = resolveProject(options.cwd);
+  // A ref is read where it is, never served: the server syncs into what it serves, and runs its
+  // slides' scripts in the browser at its own origin.
+  const project = requireProject(options.cwd);
+  if (options.deck !== undefined && isRefName(options.deck)) {
+    throw refReadOnlyError(options.deck);
+  }
   // Before the port and the watchers; writing the lock checks again, for a server that raced us.
   assertNoDevServer(project.root);
   const { scopedDeckName, deckDir } = serverScope(project, options);
@@ -113,7 +124,7 @@ export async function startDevServer(options: DevServerOptions): Promise<DevServ
   }
 
   const port = server.port ?? 0;
-  const url = `http://127.0.0.1:${port}/`;
+  const url = devServerUrl(port);
   const remoteUrls = [...new Set([url, ...(access.remote ? lanUrls(port) : [])])];
   try {
     writeDevServerLock(project.root, url, access.password, scopedDeckName);

package/src/server/lock.ts

@@ -1,7 +1,7 @@
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { DekError } from "../core/error.ts";
-import { writeInside } from "../core/safe-fs.ts";
+import { readSourceIfExists, writeInside } from "../core/safe-fs.ts";
 
 export type DevServerLock = {
   url: string;
@@ -15,7 +15,14 @@ function serverLockPath(root: string): string {
   return join(root, ".dek", "server.json");
 }
 
+/**
+ * Whether a process with this pid runs. Only a positive whole number names one process: 0 and a
+ * negative pid signal a whole group, which `kill` reports as alive.
+ */
 export function isPidAlive(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
   try {
     process.kill(pid, 0);
     return true;
@@ -24,16 +31,52 @@ export function isPidAlive(pid: number): boolean {
   }
 }
 
+/** The hosts a dev server's URL in its lock names: it writes this machine's loopback address. */
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "[::1]"]);
+
+/** The URL a dev server on `port` writes in its lock, as `URL` spells it: port 80 takes none. */
+export function devServerUrl(port: number): string {
+  return new URL(`http://127.0.0.1:${port}/`).href;
+}
+
+/**
+ * The lock's URL in the form the dev server writes it, `http://<loopback>:<port>/`, or nothing
+ * for any other. A server.json a repository brings along is its text, and the URL goes into
+ * hints and into the requests `dekc goto` sends. Port 80 is read with or without `:80`.
+ */
+function serverUrl(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    return undefined;
+  }
+  const served =
+    url.protocol === "http:" &&
+    LOOPBACK_HOSTS.has(url.hostname) &&
+    url.pathname === "/" &&
+    url.search === "" &&
+    url.hash === "" &&
+    url.username === "" &&
+    url.password === "";
+  const written = url.port === "" ? [url.href, `http://${url.hostname}:80/`] : [url.href];
+  return served && written.includes(value) ? url.href : undefined;
+}
+
 export function readDevServerLock(root: string): DevServerLock | undefined {
   const path = serverLockPath(root);
   if (!existsSync(path)) {
     return undefined;
   }
   try {
-    const parsed = JSON.parse(readFileSync(path, "utf8")) as DevServerLock;
-    if (typeof parsed.url === "string" && typeof parsed.pid === "number") {
+    const parsed = JSON.parse(readSourceIfExists(path, root) ?? "") as DevServerLock;
+    const url = serverUrl(parsed.url);
+    if (url !== undefined && typeof parsed.pid === "number") {
       return {
-        url: parsed.url,
+        url,
         pid: parsed.pid,
         ...(typeof parsed.password === "string" ? { password: parsed.password } : {}),
         ...(typeof parsed.deck === "string" ? { deck: parsed.deck } : {}),

package/src/server/routes.ts

@@ -8,7 +8,9 @@ import { escapeAttr, escapeHtml } from "../core/escape.ts";
 import { deckSlides, htmlShell, slidePlace, stampSlide } from "../core/html.ts";
 import { decodePosition } from "../core/live-protocol.ts";
 import { markedPositions, toggleMark } from "../core/marks.ts";
+import { deckProjectRoot } from "../core/path.ts";
 import type { Project, ProjectDeck } from "../core/resolve.ts";
+import { followInside } from "../core/safe-fs.ts";
 import { voiceCacheFile } from "../core/voice.ts";
 import { deckRoutePath, parseDeckRoute, splitDeckPath, type VoiceFile } from "../runtime/routes.ts";
 import { EVENT_EXPOSURE, type Exposure, mayRead, type Route } from "./auth.ts";
@@ -149,7 +151,8 @@ export function routeRequest(req: Request, ctx: RouteContext): Routed {
 const MISSING: Routed = { route: "missing", respond: notFound };
 
 function voiceResponse(deck: ProjectDeck | undefined, file: VoiceFile): Response {
-  const path = deck && voiceCacheFile(deck.dir, file);
+  // A link out of the project is no voice of the deck's, and is not served.
+  const path = deck && followInside(voiceCacheFile(deck.dir, file), deckProjectRoot(deck.dir));
   if (!path || !existsSync(path)) {
     return notFound();
   }
@@ -291,7 +294,9 @@ function jsonNotFound(deckName: string): Response {
 function safeDeckAsset(deckDir: string, relative: string): string | undefined {
   const root = join(deckDir, "assets");
   const found = fileInside(join(root, relative), root);
-  return found.kind === "file" ? found.path : undefined;
+  // assets/ may itself be a link, and then everything under what it points to is "inside" it:
+  // what is served must also be in the project, as every file dek reads is.
+  return found.kind === "file" ? followInside(found.path, deckProjectRoot(deckDir)) : undefined;
 }
 
 function jsonResponse(body: unknown, status = 200): Response {

package/src/theme/default.css

@@ -20,6 +20,9 @@
   background: var(--bg);
   color: var(--fg);
   font-family: var(--font-body);
+  /* Japanese breaks between phrases, and no paragraph ends on a word left alone. */
+  word-break: auto-phrase;
+  text-wrap: pretty;
 }
 
 .slide .slide-title {
@@ -27,6 +30,7 @@
   font-family: var(--font-title);
   font-size: var(--size-title);
   line-height: 1.2;
+  text-wrap: balance;
 }
 
 /* @layout title

package/src/video/bake.ts

@@ -9,7 +9,7 @@ import {
   type ResolvedDeck,
   requireSection,
 } from "../core/resolve.ts";
-import { dropLinks, outputDir, outputPath, replaceFile } from "../core/safe-fs.ts";
+import { dropLinks, outputDir, outputPath, replaceFile, requireInside } from "../core/safe-fs.ts";
 import { logicalSize } from "../core/size.ts";
 import { sliceTimeline, slideTimeRange, type Timeline } from "../core/timeline.ts";
 import { videoDocument } from "../core/video-document.ts";
@@ -69,7 +69,11 @@ async function bakeProjectDeck(
       hint: "run `dekc voice`",
     });
   }
-  let timeline = { ...loaded, audio: resolveTimelineAudio(loaded, timelinePath) };
+  // ffmpeg opens the audio itself, so it is resolved here: a link out of the project is an error.
+  let timeline = {
+    ...loaded,
+    audio: requireInside(resolveTimelineAudio(loaded, timelinePath), project.root),
+  };
   const fps = options.fps ?? 30;
   const size = logicalSize(deck.deck.ratio);
   const html = videoDocument({ project, deck }, await playerScript());