@hraness/dawg 0.7.0 → 0.8.0

package/src/commands/resample.ts

@@ -8,6 +8,7 @@
  * track (the `cloud` preset) holding one note across the range. The source
  * stays as it is; mute it to hear only the resample.
  */
+import { newId } from "../../core/ids.ts";
 import { mkdir, realpath, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { MAX_ORBIT } from "../../core/fx.ts";
@@ -18,6 +19,7 @@ import {
   TrackScore,
   addTrack,
   type SampleRef,
+  requirePinnedRef,
   type TrackInput,
 } from "../../core/score.ts";
 import { trackDirectories } from "../../core/sdk/print.ts";
@@ -155,13 +157,16 @@ export function addResampleTrack(
   trackId: string,
   src: string,
 ): TrackScore {
-  const ref: SampleRef = {
-    src,
-    sha256: render.sha256,
-    from: render.from,
-    // A bounce starts at full level: no anti-click fade-in.
-    ...(command.grain ? {} : { gain: RESAMPLE_GAIN, fadeInTime: 0 }),
-  };
+  const ref: SampleRef = requirePinnedRef(
+    {
+      src,
+      sha256: render.sha256,
+      from: render.from,
+      // A bounce starts at full level: no anti-click fade-in.
+      ...(command.grain ? {} : { gain: RESAMPLE_GAIN, fadeInTime: 0 }),
+    },
+    "resample",
+  );
   const track: TrackInput = command.grain
     ? {
         id: trackId,
@@ -183,15 +188,13 @@ export function addResampleTrack(
   // plays the source at its own pitch.
   const pitch = command.grain ? 60 : 36;
   const notes = next.notes;
-  let n = 1;
-  while (notes.some((note) => note.id === `${trackId}-${n}`)) n += 1;
   const ticks = Math.min(render.durationTicks, next.bars * barTicks(next));
   next = new TrackScore({
     ...next.toJSON(),
     notes: [
       ...notes,
       {
-        id: `${trackId}-${n}`,
+        id: newId(trackId),
         trackId,
         startTick: render.startTick,
         durationTicks: Math.max(1, ticks),

package/src/commands/sample.ts

@@ -24,6 +24,9 @@ import {
   samplerVoiceSlots,
   type Sampler,
   type SampleRef,
+  type PinnedSampleRef,
+  requirePinnedRef,
+  ScoreValidationError,
   type Track,
 } from "../../core/score.ts";
 import { trackDirectories } from "../../core/sdk/print.ts";
@@ -317,8 +320,15 @@ export function addSampleVoice(
   score: TrackScore,
   trackId: string,
   voice: string,
-  ref: SampleRef,
+  ref: PinnedSampleRef,
 ): AddVoiceResult {
+  try {
+    requirePinnedRef(ref, `sample ${voice}`);
+  } catch (error) {
+    if (error instanceof ScoreValidationError)
+      return { ok: false, message: `sample · ${error.message}` };
+    throw error;
+  }
   if (!VOICE.test(voice))
     return {
       ok: false,

package/src/commands/sing.ts

@@ -19,6 +19,7 @@
  * Any edit makes the track a sing track (`instrument "sing"` plus a `sing`
  * field). One `updateTrack` revision and one undo step per command.
  */
+import { newId } from "../../core/ids.ts";
 import { isGuideInstrument } from "../../core/clips.ts";
 import { parseKey } from "../../core/chords.ts";
 import { FxValidationError } from "../../core/params.ts";
@@ -330,18 +331,13 @@ export function throatDemo(
   if (drone === undefined) return undefined;
   const step = score.ticksPerBeat * 2;
   const total = score.ticksPerBeat * score.beatsPerBar * score.bars;
-  const ids = new Set(score.notes.map((note) => note.id));
   let next = score;
   let count = 0;
   for (const [index, offset] of THROAT_DEMO_STEPS.entries()) {
     const startTick = index * step;
     if (startTick + step > total) break;
-    let id = `${trackId}-demo-${index + 1}`;
-    for (let n = 2; ids.has(id); n += 1)
-      id = `${trackId}-demo-${index + 1}-${n}`;
-    ids.add(id);
     next = addNote(next, {
-      id,
+      id: newId(`${trackId}-demo`),
       trackId,
       startTick,
       durationTicks: step,

package/src/commands/vocal-pitch.ts

@@ -8,6 +8,7 @@
  * through `core/key.ts`, the same estimator `/media analyze` uses), so a
  * long held tonic weighs more than a passing tone.
  */
+import { newId } from "../../core/ids.ts";
 import {
   TrackScore,
   SCORE_LIMITS,
@@ -338,7 +339,7 @@ export function guideNotesScore(
     );
     if (startTick < 0 || startTick >= end) continue;
     notes.push({
-      id: `${trackId}-${notes.length + 1}`,
+      id: newId(trackId),
       trackId,
       startTick,
       durationTicks: Math.max(1, endTick - startTick),

package/src/identity/actor.ts

@@ -0,0 +1,127 @@
+/**
+ * Actor identity placeholder: who made an edit, stable across windows and
+ * restarts on one machine. No keys and no login; a later signed identity can
+ * bind to this id. It is sent only on the session protocol (`hello`), never
+ * to model gateways or anywhere else.
+ *
+ * File: `<config>/actor.json` = `{ "id": "a_<22 base32>", "name": "$USER" }`,
+ * created once with an exclusive atomic write so concurrent first runs agree.
+ */
+import { link, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { userInfo } from "node:os";
+import { join } from "node:path";
+import { configDir } from "../auth/credentials.ts";
+import { randomBase32, setIdSalt } from "../../core/ids.ts";
+
+export type Actor = Readonly<{ id: string; name: string }>;
+
+export const ACTOR_ID = /^a_[a-z2-7]{22}$/;
+const MAX_NAME_LENGTH = 64;
+
+export function isActorId(value: unknown): value is string {
+  return typeof value === "string" && ACTOR_ID.test(value);
+}
+
+export function actorPath(dir: string = configDir()): string {
+  return join(dir, "actor.json");
+}
+
+function defaultName(env: Readonly<Record<string, string | undefined>>) {
+  let name = env.USER || env.LOGNAME || "";
+  if (!name) {
+    try {
+      name = userInfo().username;
+    } catch {
+      name = "";
+    }
+  }
+  return cleanName(name) || "me";
+}
+
+function cleanName(value: unknown): string {
+  if (typeof value !== "string") return "";
+  return value
+    .replace(/[\u0000-\u001f\u007f]/g, "")
+    .trim()
+    .slice(0, MAX_NAME_LENGTH);
+}
+
+function parseActor(text: string): Actor | undefined {
+  try {
+    const value = JSON.parse(text) as Record<string, unknown>;
+    if (typeof value !== "object" || value === null) return undefined;
+    if (!isActorId(value.id)) return undefined;
+    return { id: value.id, name: cleanName(value.name) || "me" };
+  } catch {
+    return undefined;
+  }
+}
+
+let cached: Actor | undefined;
+
+/** A process-local actor that is never written (tests, read-only configs). */
+export function ephemeralActor(name = "me"): Actor {
+  return { id: `a_${randomBase32(22)}`, name: cleanName(name) || "me" };
+}
+
+/**
+ * Reads the actor file, creating it on first run. A corrupt file is replaced
+ * (the old id is unrecoverable anyway). Never throws: an unwritable config
+ * dir yields an ephemeral actor for this process.
+ */
+export async function loadActor(
+  options: {
+    dir?: string;
+    env?: Readonly<Record<string, string | undefined>>;
+  } = {},
+): Promise<Actor> {
+  const env = options.env ?? process.env;
+  const dir = options.dir ?? configDir(env);
+  const path = actorPath(dir);
+  const existing = await readFile(path, "utf8").then(
+    parseActor,
+    () => undefined,
+  );
+  if (existing) return existing;
+  const fresh = ephemeralActor(defaultName(env));
+  try {
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    const temp = `${path}.${randomUUID()}.tmp`;
+    await writeFile(temp, `${JSON.stringify(fresh)}\n`, { mode: 0o600 });
+    try {
+      // link() fails if the file exists: the first writer wins, others adopt it.
+      await link(temp, path);
+    } catch (error) {
+      const code = (error as { code?: string }).code;
+      if (code !== "EEXIST") throw error;
+      const winner = await readFile(path, "utf8").then(
+        parseActor,
+        () => undefined,
+      );
+      if (winner) return winner;
+      // Corrupt file: replace it.
+      await rm(path, { force: true });
+      await link(temp, path);
+    } finally {
+      await rm(temp, { force: true });
+    }
+    return fresh;
+  } catch {
+    return fresh;
+  }
+}
+
+/** Process-wide actor, loaded once; also salts `newId`. */
+export async function currentActor(): Promise<Actor> {
+  if (!cached) {
+    cached = await loadActor();
+    setIdSalt(cached.id);
+  }
+  return cached;
+}
+
+/** Tests only. */
+export function resetActorCache(): void {
+  cached = undefined;
+}

package/src/lang/glossary.ts

@@ -398,6 +398,24 @@ export const TERMS: readonly Term[] = [
     losers: ["STEER", "QUEUE"],
     aliases: [],
   },
+  {
+    term: "range",
+    meaning: "bars a to b on one track or all (copy bass 5-6 to 7)",
+    losers: [],
+    aliases: [],
+  },
+  {
+    term: "clipboard",
+    meaning: "what copy without `to` holds until paste (tape c, x, v)",
+    losers: [],
+    aliases: [],
+  },
+  {
+    term: "pane",
+    meaning: "one terminal on a shared session, with a letter and own undo",
+    losers: [],
+    aliases: [],
+  },
 ];
 
 /** British spellings dawg writes the American way (lowercase keys). */

package/src/launch-args.ts

@@ -40,8 +40,27 @@ export const BOOLEAN_FLAGS: readonly string[] = [
 /** A `--track` value resolved to the id `/track` would use. */
 export type TrackArg = { id: string; name: string };
 
+/** Screens a pane can open on (§12.5). */
+export const PANE_SCREENS = ["home", "play", "tape", "sound", "menu"] as const;
+export type PaneScreen = (typeof PANE_SCREENS)[number];
+
+/**
+ * `dawg pane <screen> [track] [param] [pin | follow [letter]]`: what this
+ * terminal shows of the session in the current directory. `sound` opens
+ * the drawer on `param` (default volume); `menu` opens `param` as a menu
+ * section. `follow` tracks another pane's focus (`*` = the latest).
+ */
+export type PaneArgs = {
+  screen: PaneScreen;
+  param: string | undefined;
+  pin: boolean;
+  follow: string | undefined;
+};
+
 export type LaunchArgs = {
   subcommand: string | undefined;
+  /** `dawg pane …` (its track is `track`). */
+  pane?: PaneArgs;
   flags: ReadonlySet<string>;
   session: string | undefined;
   track: TrackArg | undefined;
@@ -90,6 +109,7 @@ export function parseLaunchArgs(argv: readonly string[]): LaunchParse {
   const flags = new Set<string>();
   const values = new Map<ValueFlag, string>();
   const first = argv[0];
+  if (first === "pane") return parsePaneArgs(argv.slice(1));
   if (first !== undefined && !first.startsWith("-")) {
     if (SUBCOMMANDS.includes(first))
       return { ok: true, args: emptyArgs(first, flags) };
@@ -146,7 +166,91 @@ export function parseLaunchArgs(argv: readonly string[]): LaunchParse {
   };
 }
 
-function emptyArgs(subcommand: string, flags: Set<string>): LaunchArgs {
+/** Drawer parameters `dawg pane sound <word>` opens (else the word is a track). */
+const SOUND_PARAMS: readonly string[] = [
+  "volume",
+  "pan",
+  "tempo",
+  "bpm",
+  "bars",
+  "meter",
+];
+
+const PANE_USAGE =
+  "usage: dawg pane home|play|tape|sound|menu [track] [volume|pan|section] [pin|follow [A-Z]]";
+
+export function parsePaneArgs(argv: readonly string[]): LaunchParse {
+  const [screenWord, ...rest] = argv;
+  const screen = PANE_SCREENS.find(
+    (name) => name === screenWord?.toLowerCase(),
+  );
+  if (!screen)
+    return {
+      ok: false,
+      problem: screenWord
+        ? `unknown pane screen ${clip(screenWord)} · ${PANE_USAGE}`
+        : PANE_USAGE,
+    };
+  let pin = false;
+  let follow: string | undefined;
+  const words: string[] = [];
+  for (let index = 0; index < rest.length; index += 1) {
+    const word = rest[index]!;
+    if (word === "pin") pin = true;
+    else if (word === "follow") {
+      const letter = rest[index + 1];
+      if (letter !== undefined && /^[A-Z]$/i.test(letter)) {
+        follow = letter.toUpperCase();
+        index += 1;
+      } else follow = "*";
+    } else if (word.startsWith("-"))
+      return {
+        ok: false,
+        problem: `unknown option · ${clip(word)} · ${PANE_USAGE}`,
+      };
+    else words.push(word);
+  }
+  if (pin && follow)
+    return { ok: false, problem: `pin or follow, not both · ${PANE_USAGE}` };
+  if (words.length > 2)
+    return { ok: false, problem: `too many words · ${PANE_USAGE}` };
+  let track: TrackArg | undefined;
+  // `menu mix`, `sound filter`: one word after these is the section or the
+  // parameter; a track then comes first (`sound bass filter`).
+  const [first, second] = words;
+  let param: string | undefined;
+  const trackFirst =
+    words.length === 2 ||
+    (first !== undefined &&
+      (screen === "home" ||
+        screen === "play" ||
+        (screen === "sound" && !SOUND_PARAMS.includes(first.toLowerCase()))));
+  if (trackFirst) {
+    track = normalizeTrackArg(first!);
+    if (!track) return { ok: false, problem: "invalid track name" };
+    param = second;
+  } else param = first;
+  if (param !== undefined && !/^[a-z][a-z0-9 ._-]{0,63}$/i.test(param))
+    return { ok: false, problem: `invalid pane parameter · ${PANE_USAGE}` };
+  if (param !== undefined && (screen === "home" || screen === "play"))
+    return {
+      ok: false,
+      problem: `${screen} takes a track only · ${PANE_USAGE}`,
+    };
+  return {
+    ok: true,
+    args: {
+      ...emptyArgs(undefined, new Set()),
+      track,
+      pane: { screen, param: param?.toLowerCase(), pin, follow },
+    },
+  };
+}
+
+function emptyArgs(
+  subcommand: string | undefined,
+  flags: Set<string>,
+): LaunchArgs {
   return {
     subcommand,
     flags,