@hraness/dawg 0.0.0-stage → 0.2.0

package/src/render.ts

@@ -0,0 +1,99 @@
+/**
+ * `dawg render <out.wav>`: renders a session (or a `track.loop/v1` file) to
+ * a stereo 16-bit PCM WAV through the same deterministic renderer playback
+ * uses, so two renders of one score are byte-identical. It reads the session
+ * record from disk and never starts dawgd or plays audio.
+ */
+import { createHash } from "node:crypto";
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { scoreFromJSON, type TrackScore } from "../core/score.ts";
+import { decodeLoop } from "../core/loop.ts";
+import { renderScoreWav } from "./audio/wav.ts";
+import { resolveSessionArg } from "./session/attach.ts";
+import {
+  loadSession,
+  readCurrentSessionId,
+  sessionPaths,
+} from "./session/store.ts";
+
+export const RENDER_USAGE =
+  "usage: dawg render <out.wav> [--session <name|id>] [--import <file.track.json>]";
+
+const MAX_LOOP_FILE_BYTES = 512 * 1024;
+
+type Output = { write(text: string): unknown };
+
+export async function runRenderCommand(
+  argv: readonly string[],
+  workspace: string,
+  stdout: Output,
+  stderr: Output,
+): Promise<number> {
+  const rest = argv.slice(1);
+  const options = new Map<string, string>();
+  const positional: string[] = [];
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index]!;
+    if (arg === "--session" || arg === "--import") {
+      const value = rest[index + 1];
+      if (value === undefined || value.startsWith("--")) {
+        stderr.write(`${arg} needs a value\n${RENDER_USAGE}\n`);
+        return 2;
+      }
+      options.set(arg, value);
+      index += 1;
+    } else if (arg.startsWith("--")) {
+      stderr.write(`unknown option ${arg}\n${RENDER_USAGE}\n`);
+      return 2;
+    } else positional.push(arg);
+  }
+  const target = positional[0];
+  if (positional.length !== 1 || !target || !/\.wav$/i.test(target)) {
+    stderr.write(`${RENDER_USAGE}\n`);
+    return 2;
+  }
+  let score: TrackScore;
+  try {
+    score = await loadScore(workspace, options);
+  } catch (error) {
+    stderr.write(
+      `render failed · ${error instanceof Error ? error.message : String(error)}\n`,
+    );
+    return 1;
+  }
+  const wav = renderScoreWav(score);
+  const path = resolve(workspace, target);
+  const temporary = `${path}.${process.pid}.tmp`;
+  await writeFile(temporary, wav);
+  await rename(temporary, path);
+  const sha = createHash("sha256").update(wav).digest("hex");
+  stdout.write(`rendered · ${target} · ${wav.byteLength} bytes · ${sha}\n`);
+  return 0;
+}
+
+async function loadScore(
+  workspace: string,
+  options: ReadonlyMap<string, string>,
+): Promise<TrackScore> {
+  const importPath = options.get("--import");
+  if (importPath !== undefined) {
+    const contents = await readFile(resolve(workspace, importPath));
+    if (contents.byteLength > MAX_LOOP_FILE_BYTES)
+      throw new Error("loop import exceeds 512 KiB");
+    return decodeLoop(contents.toString("utf8"));
+  }
+  const query = options.get("--session");
+  const sessionId =
+    query === undefined
+      ? await readCurrentSessionId(workspace)
+      : await resolveSessionArg(workspace, query);
+  if (sessionId === undefined)
+    throw new Error("no session here; run `dawg` first or pass --import");
+  const record = await loadSession<unknown>(
+    sessionPaths(workspace, sessionId),
+  ).catch(() => {
+    throw new Error(`no session named "${query ?? sessionId}"`);
+  });
+  return scoreFromJSON(record.composition);
+}

package/src/session/attach.ts

@@ -0,0 +1,182 @@
+/**
+ * Glue between the TUI and sessions: resolving `--session <name|id>`,
+ * choosing a track for a newly opened window, materializing draft tracks,
+ * forking, and the auto-namer's port-backed target. Kept out of main.ts so
+ * the entry point only wires these together.
+ */
+import { isDrumInstrument } from "../../core/drums.ts";
+import type { TrackScore } from "../../core/score.ts";
+import {
+  ambiguousSessionMessage,
+  listSessions,
+  resolveSession,
+  type SessionSummary,
+} from "./list.ts";
+import {
+  forkName,
+  normalizeSessionName,
+  uniqueName,
+  type SessionMeta,
+} from "./meta.ts";
+import type { NamingTarget } from "./naming.ts";
+import type { SessionPort } from "./port.ts";
+import {
+  createForkSession,
+  inheritedEvents,
+  setCurrentSession,
+  type SessionEvent,
+  type SessionRecord,
+} from "./store.ts";
+
+export const ALL_TRACKS_OPEN_HINT = "all tracks open · new track";
+
+export class SessionLookupError extends Error {
+  public constructor(message: string) {
+    super(message);
+    this.name = "SessionLookupError";
+  }
+}
+
+/**
+ * Maps `--session <name|id>` to a session id. Unknown values pass through
+ * unchanged when they are valid ids (a new session with that id is created);
+ * an ambiguous name throws with the candidate list.
+ */
+export async function resolveSessionArg(
+  workspace: string,
+  query: string,
+  sessions?: readonly SessionSummary[],
+): Promise<string> {
+  const listed = sessions ?? (await listSessions(workspace));
+  const result = resolveSession(listed, query);
+  if (result.status === "found") return result.session.sessionId;
+  if (result.status === "ambiguous")
+    throw new SessionLookupError(
+      ambiguousSessionMessage(query, result.candidates),
+    );
+  if (/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(query)) return query;
+  throw new SessionLookupError(`no session named "${query}"`);
+}
+
+export type TrackAttachment = {
+  trackId: string;
+  /** Reserved id not yet in the score; created on the first edit. */
+  draft: boolean;
+  /** How the track was chosen, for the activity strip. */
+  reason: "explicit" | "claimed" | "draft";
+};
+
+/**
+ * `--track` always wins (focus is published but not exclusive). Otherwise
+ * atomically claim the first track no live window has focused, or a draft.
+ */
+export async function attachTrack<T>(
+  port: SessionPort<T>,
+  score: TrackScore,
+  explicit: string | undefined,
+): Promise<TrackAttachment> {
+  if (explicit !== undefined) {
+    await port.focus(explicit).catch(() => undefined);
+    return { trackId: explicit, draft: false, reason: "explicit" };
+  }
+  const claim = await port.claimOrDraft(score.tracks.map((track) => track.id));
+  return {
+    trackId: claim.trackId,
+    draft: claim.draft,
+    reason: claim.draft ? "draft" : "claimed",
+  };
+}
+
+/** Score with `trackId` present: a draft becomes a real track here. */
+export function withTrack(score: TrackScore, trackId: string): TrackScore {
+  if (score.tracks.some((track) => track.id === trackId)) return score;
+  const draft = trackId.match(/^track-(\d+)$/);
+  return score.withTracks([
+    ...score.tracks,
+    {
+      id: trackId,
+      name: draft ? `track ${draft[1]}` : trackId,
+      instrument: isDrumInstrument(trackId) ? "kit" : "sine",
+    },
+  ]);
+}
+
+/** Copies `source` into a new session named per the fork rules. */
+export async function forkSession<T>(
+  workspace: string,
+  source: SessionRecord<T>,
+  requested: string | undefined,
+): Promise<SessionRecord<T>> {
+  const others = (await listSessions(workspace))
+    .filter((session) => !session.error)
+    .map((session) => session.name);
+  const name =
+    requested !== undefined && requested.trim().length > 0
+      ? uniqueName(normalizeSessionName(requested), others)
+      : forkName(source.meta.name, others);
+  const record = await createForkSession(workspace, source, name);
+  await setCurrentSession(workspace, record.sessionId);
+  return record;
+}
+
+const inheritedCache = new Map<string, Promise<SessionEvent[]>>();
+
+/**
+ * The event log undo/redo replays: the fork ancestry's prefix (see
+ * `inheritedEvents`), then this session's own events. Undo in a fork can
+ * therefore step back past the fork point into the parent's edits. The
+ * inherited prefix never changes, so it is cached per lineage.
+ */
+export async function historyEvents<T>(
+  workspace: string,
+  record: SessionRecord<T>,
+): Promise<SessionEvent[]> {
+  const fork = record.meta.forkOf;
+  if (!fork) return record.events;
+  const key = `${workspace}\0${record.sessionId}\0${fork.sessionId}@${fork.revision}`;
+  let inherited = inheritedCache.get(key);
+  if (!inherited) {
+    inherited = inheritedEvents(workspace, record.meta, record.sessionId);
+    if (inheritedCache.size > 32) inheritedCache.clear();
+    inheritedCache.set(key, inherited);
+  }
+  return [...(await inherited), ...record.events];
+}
+
+/** The auto-namer's view of the live session. */
+export function namingTarget<T>(
+  workspace: string,
+  current: () => { port: SessionPort<T>; record: SessionRecord<T> },
+  adopt: (meta: SessionMeta) => void,
+): NamingTarget {
+  return {
+    meta: () => current().record.meta,
+    updateMeta: async (patch, expect) => {
+      const result = await current().port.updateMeta(patch, expect);
+      adopt(result.meta);
+      return result;
+    },
+    otherNames: async () => {
+      const id = current().record.sessionId;
+      return (await listSessions(workspace))
+        .filter((session) => !session.error && session.sessionId !== id)
+        .map((session) => session.name);
+    },
+  };
+}
+
+/** `/resume` picker text: numbered recent sessions. */
+export function pickerLines(
+  sessions: readonly SessionSummary[],
+  currentId: string,
+  format: (session: SessionSummary) => string,
+  limit = 9,
+): string[] {
+  return sessions
+    .filter((session) => !session.error)
+    .slice(0, limit)
+    .map(
+      (session, index) =>
+        `${index + 1}${session.sessionId === currentId ? "*" : " "} ${format(session)}`,
+    );
+}