@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-frontend/src/runtime/browser/services/tests/service-ui.smoke.test.tsx

@@ -0,0 +1,140 @@
+import React from "react";
+import { describe, expect, it, vi } from "vitest";
+
+type AnyComponent = (props: any) => React.ReactElement | null;
+
+const serviceModuleLoaders = import.meta.glob("../*.{ts,tsx,js,jsx}");
+const candidateEntries = Object.entries(serviceModuleLoaders).filter(
+  ([modulePath]) => {
+    if (modulePath.includes(".test.")) {
+      return false;
+    }
+    const fileName = modulePath.split("/").at(-1) || "";
+    // Match files that either end in UI.tsx or contain UI in their name
+    return (
+      fileName.includes("UI.") ||
+      fileName.endsWith("UI.tsx") ||
+      fileName.endsWith("UI.jsx") ||
+      fileName.endsWith("UI.ts") ||
+      fileName.endsWith("UI.js")
+    );
+  },
+);
+
+function createMockService() {
+  const app = {
+    registerNotificationTarget: vi.fn(),
+    unregisterNotificationTarget: vi.fn(),
+    createSubServiceUI: vi.fn(() => null),
+    listAvailableServices: vi.fn(() => []),
+    createSubService: vi.fn(async () => null),
+    getServiceById: vi.fn(() => null),
+    sendAction: vi.fn(),
+    notify: vi.fn(),
+    storeServiceData: vi.fn(),
+    restoreServiceData: vi.fn(),
+    removeServiceData: vi.fn(),
+  };
+
+  return {
+    app,
+    uuid: "svc-1",
+    serviceId: "test/service",
+    serviceName: "Test Service",
+    board: "test-board",
+    state: {},
+    steps: [],
+    currentStep: 0,
+    repeat: false,
+    register: vi.fn(),
+    unregister: vi.fn(),
+    configure: vi.fn(),
+    process: vi.fn(),
+    getConfiguration: vi.fn(async () => ({})),
+    destroy: vi.fn(),
+  };
+}
+
+function extractUiComponents(
+  modulePath: string,
+  mod: Record<string, unknown>,
+): AnyComponent[] {
+  const fileName = modulePath.split("/").at(-1) || "";
+  const found: AnyComponent[] = [];
+
+  const defaultExport = mod.default as unknown;
+  if (typeof defaultExport === "function") {
+    found.push(defaultExport as AnyComponent);
+  }
+
+  if (
+    defaultExport &&
+    typeof defaultExport === "object" &&
+    "createUI" in (defaultExport as Record<string, unknown>)
+  ) {
+    const createUI = (defaultExport as { createUI?: unknown }).createUI;
+    if (typeof createUI === "function") {
+      found.push(createUI as AnyComponent);
+    }
+  }
+
+  for (const [name, value] of Object.entries(mod)) {
+    if (name.endsWith("UI") && typeof value === "function") {
+      found.push(value as AnyComponent);
+    }
+  }
+
+  return Array.from(new Set(found));
+}
+
+function instantiateWithoutThrow(Component: AnyComponent): void {
+  const service = createMockService();
+  const props = {
+    service,
+    boardName: "test-board",
+    runtimeId: "runtime-1",
+    userId: "user-1",
+    registry: {
+      findServiceModule: vi.fn(),
+      getServiceClasses: vi.fn(() => []),
+    },
+    runtime: {
+      id: "runtime-1",
+      app: service.app,
+    },
+    onServiceAction: vi.fn(),
+    children: React.createElement("div", null, "content"),
+    segments: [
+      {
+        name: "main",
+        render: () => React.createElement("div", null, "segment"),
+      },
+    ],
+  };
+
+  const element = React.createElement(Component, props);
+  expect(React.isValidElement(element)).toBe(true);
+}
+
+describe("runtime browser service UI smoke tests", () => {
+  it("finds service UI modules to validate", () => {
+    expect(candidateEntries.length).toBeGreaterThan(0);
+  });
+
+  for (const [modulePath, loadModule] of candidateEntries) {
+    it(`${modulePath} exports at least one UI component`, async () => {
+      const mod = (await loadModule()) as Record<string, unknown>;
+      const components = extractUiComponents(modulePath, mod);
+      expect(components.length).toBeGreaterThan(0);
+    }, 15000);
+
+    it(`${modulePath} UI components can be instantiated`, async () => {
+      const mod = (await loadModule()) as Record<string, unknown>;
+      const components = extractUiComponents(modulePath, mod);
+      expect(components.length).toBeGreaterThan(0);
+      for (const Component of components) {
+        expect(() => instantiateWithoutThrow(Component)).not.toThrow();
+      }
+    });
+  }
+});

package/bundle/hkp-frontend/src/runtime/browser/services/tests/sound-service.test.ts

@@ -0,0 +1,293 @@
+/**
+ * Sound service — what plays for an input, and on which audio context.
+ *
+ * jsdom has no Web Audio, so a stub context records the nodes a sound builds:
+ * a kick is one oscillator, a hi-hat one noise source through a high-pass
+ * filter, a snare both a noise source and an oscillator.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import SoundDescriptor from "../Sound";
+
+class StubParam {
+  value = 0;
+  /** Every change scheduled, as [what, value, when]. */
+  calls: Array<[string, number, number]> = [];
+  setValueAtTime(value: number, time: number) {
+    this.calls.push(["set", value, time]);
+  }
+  exponentialRampToValueAtTime(value: number, time: number) {
+    this.calls.push(["exp", value, time]);
+  }
+  linearRampToValueAtTime(value: number, time: number) {
+    this.calls.push(["linear", value, time]);
+  }
+}
+
+class StubNode {
+  frequency = new StubParam();
+  gain = new StubParam();
+  Q = new StubParam();
+  type = "";
+  buffer: unknown = null;
+  stoppedAt: number | null = null;
+  connect() {}
+  start() {}
+  stop(time: number) {
+    this.stoppedAt = time;
+  }
+  setPeriodicWave() {}
+}
+
+let contexts: StubAudioContext[] = [];
+
+class StubAudioContext {
+  state = "running";
+  currentTime = 0;
+  sampleRate = 44100;
+  destination = {};
+  created: string[] = [];
+  gains: StubNode[] = [];
+  oscillators: StubNode[] = [];
+  constructor() {
+    contexts.push(this);
+  }
+  createOscillator() {
+    this.created.push("oscillator");
+    const node = new StubNode();
+    this.oscillators.push(node);
+    return node;
+  }
+  createBufferSource() {
+    this.created.push("noise");
+    return new StubNode();
+  }
+  createBiquadFilter() {
+    return new StubNode();
+  }
+  createGain() {
+    const node = new StubNode();
+    this.gains.push(node);
+    return node;
+  }
+  createBuffer(_channels: number, length: number) {
+    return { getChannelData: () => new Float32Array(length) };
+  }
+  createPeriodicWave() {
+    return {};
+  }
+  resume() {}
+  close() {
+    this.state = "closed";
+  }
+}
+
+function createSound(slots?: Map<string, unknown>) {
+  const app = {
+    notify: vi.fn(),
+    next: vi.fn(),
+    sendAction: vi.fn(),
+    ...(slots ? { slots: () => slots } : {}),
+  };
+  const sound = SoundDescriptor.create(
+    app as any,
+    "test-board",
+    {} as any,
+    "sound-1",
+  ) as any;
+  return { sound, app };
+}
+
+beforeEach(() => {
+  contexts = [];
+  vi.useFakeTimers();
+  vi.stubGlobal("AudioContext", StubAudioContext);
+});
+
+afterEach(() => {
+  // Every test destroys its Sounds; this lets the deferred close happen, so the
+  // next test opens a context of its own.
+  vi.runAllTimers();
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+});
+
+describe("Sound – trigger", () => {
+  it("plays nothing for an input that names no note, when no trigger is set", () => {
+    const { sound } = createSound();
+    sound.process({ triggerCount: 1 });
+    expect(contexts.flatMap((c) => c.created)).toEqual([]);
+    sound.destroy();
+  });
+
+  it("plays the trigger drum for an input that names no note", () => {
+    const { sound, app } = createSound();
+    sound.configure({ trigger: "kick" });
+    expect(app.notify).toHaveBeenCalledWith(sound, { trigger: "kick" });
+
+    const tick = { triggerCount: 1 };
+    // Passed through unchanged, so a chain of sounds can share one tick.
+    expect(sound.process(tick)).toBe(tick);
+    expect(contexts[0].created).toEqual(["oscillator"]);
+    sound.destroy();
+  });
+
+  it("lets a note the input names win over the trigger", () => {
+    const { sound } = createSound();
+    sound.configure({ trigger: "kick" });
+    sound.process({ note: "E4" }); // hi-hat in the default drum map
+    expect(contexts[0].created).toEqual(["noise"]);
+    sound.destroy();
+  });
+
+  it("plays a trigger note name in synth mode", () => {
+    const { sound } = createSound();
+    sound.configure({ generator: "synth", trigger: "A4" });
+    sound.process({ triggerCount: 1 });
+    expect(contexts[0].created).toEqual(["oscillator"]);
+    sound.destroy();
+  });
+
+  it("clears the trigger when configured empty", () => {
+    const { sound } = createSound();
+    sound.configure({ trigger: "snare" });
+    sound.configure({ trigger: null });
+    expect(sound.state.trigger).toBeNull();
+    sound.process({ triggerCount: 1 });
+    expect(contexts.flatMap((c) => c.created)).toEqual([]);
+    sound.destroy();
+  });
+});
+
+describe("Sound – audio context", () => {
+  it("opens the context when a Sound is created, before the first note", () => {
+    // Opening one blocks while the audio device starts; paid on the first
+    // note, that note would play late.
+    const { sound } = createSound();
+    expect(contexts).toHaveLength(1);
+    sound.destroy();
+  });
+
+  it("shares one context across instances and closes it a while after the last", () => {
+    const { sound: a } = createSound();
+    const { sound: b } = createSound();
+    a.configure({ trigger: "kick" });
+    b.configure({ trigger: "snare" });
+    a.process({});
+    b.process({});
+    expect(contexts).toHaveLength(1);
+
+    a.destroy();
+    b.destroy();
+    expect(contexts[0].state).toBe("running");
+    vi.advanceTimersByTime(5000);
+    expect(contexts[0].state).toBe("closed");
+  });
+
+  it("keeps the context for a Sound created again soon after", () => {
+    // A pipeline rebuilt around its Sounds destroys and recreates them; that
+    // must not reopen the audio device.
+    const { sound: a } = createSound();
+    a.destroy();
+    vi.advanceTimersByTime(1000);
+    const { sound: b } = createSound();
+    vi.advanceTimersByTime(10_000);
+    expect(contexts).toHaveLength(1);
+    expect(contexts[0].state).toBe("running");
+    b.destroy();
+  });
+
+  it("resumes a context opened before any gesture on the first one", () => {
+    class SuspendedContext extends StubAudioContext {
+      state = "suspended";
+      resumed = 0;
+      resume() {
+        this.resumed += 1;
+      }
+    }
+    vi.stubGlobal("AudioContext", SuspendedContext);
+    const { sound } = createSound();
+    const ctx = contexts[0] as SuspendedContext;
+    const before = ctx.resumed;
+
+    window.dispatchEvent(new Event("pointerdown"));
+    expect(ctx.resumed).toBe(before + 1);
+    // Once: the listener goes with the gesture that used it.
+    window.dispatchEvent(new Event("pointerdown"));
+    expect(ctx.resumed).toBe(before + 1);
+    sound.destroy();
+  });
+});
+
+describe("Sound – envelope", () => {
+  it("rises over the attack, holds for the duration, then fades over the release", () => {
+    const { sound } = createSound();
+    sound.configure({
+      generator: "synth",
+      volume: 0.5,
+      attack: 0.4,
+      noteDuration: 2,
+      release: 1,
+    });
+    sound.process({ note: "A3" });
+    const [gain] = contexts[0].gains;
+    expect(gain.gain.calls).toEqual([
+      ["set", 0, 0],
+      ["linear", 0.5, 0.4],
+      ["set", 0.5, 2],
+      ["linear", 0, 3],
+    ]);
+    // Sounding through its release, not cut at the end of the duration.
+    expect(contexts[0].oscillators[0].stoppedAt).toBe(3);
+    sound.destroy();
+  });
+
+  it("fades from where it got to when let go before the attack is over", () => {
+    const { sound } = createSound();
+    sound.configure({ generator: "synth", volume: 1, attack: 1, noteDuration: 0.25, release: 0.5 });
+    sound.process({ note: "A3" });
+    expect(contexts[0].gains[0].gain.calls).toEqual([
+      ["set", 0, 0],
+      ["linear", 0.25, 0.25],
+      ["linear", 0, 0.75],
+    ]);
+    sound.destroy();
+  });
+
+  it("holds a note for beats of the tempo held in the tempo slot", () => {
+    const slots = new Map<string, unknown>([["tempo", 90]]);
+    const { sound, app } = createSound(slots);
+    sound.configure({ generator: "synth", noteDuration: 3, noteDurationUnit: "beats", release: 0 });
+    expect(app.notify).toHaveBeenCalledWith(sound, {
+      noteDuration: 3,
+      release: 0,
+      noteDurationUnit: "beats",
+    });
+    sound.process({ note: "A3" });
+    // Three beats at 90 BPM.
+    expect(contexts[0].oscillators[0].stoppedAt).toBeCloseTo(2);
+    // Read as each note starts: a tempo change applies to the next one.
+    slots.set("tempo", 180);
+    sound.process({ note: "A3" });
+    expect(contexts[0].oscillators[1].stoppedAt).toBeCloseTo(1);
+    sound.destroy();
+  });
+
+  it("plays a list of named notes, held in beats of the tempo it carries", () => {
+    // A slot says 60, the input says 120: what came with the notes wins.
+    const slots = new Map<string, unknown>([["tempo", 60]]);
+    const { sound } = createSound(slots);
+    sound.configure({ generator: "synth", noteDuration: 4, noteDurationUnit: "beats", release: 0 });
+    sound.process({ notes: [{ note: "A3" }, { note: "C4" }], tempo: 120 });
+    expect(contexts[0].oscillators.map((o) => o.stoppedAt)).toEqual([2, 2]);
+    sound.destroy();
+  });
+
+  it("plays every note of a chord with the same envelope", () => {
+    const { sound } = createSound();
+    sound.configure({ generator: "synth", noteDuration: 1, release: 0.5 });
+    sound.process([{ note: "A3" }, { note: "C4" }, { note: "E4" }]);
+    expect(contexts[0].oscillators.map((o) => o.stoppedAt)).toEqual([1.5, 1.5, 1.5]);
+    sound.destroy();
+  });
+});

package/bundle/hkp-frontend/src/runtime/browser/services/tests/spread-service.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it, vi } from "vitest";
+
+import api from "../../BrowserRuntimeApi";
+import BrowserRuntimeScope from "../../BrowserRuntimeScope";
+import SpreadDescriptor from "../Spread";
+import { chunkText } from "../FileSource";
+import { ProcessContext } from "hkp-frontend/src/types";
+
+/**
+ * Spread: one value in, as many out as it has items. What is worth pinning is
+ * that each item leaves the runtime by itself — that is the whole reason the
+ * service exists — and what each one carries for a Gather to put the array
+ * back together.
+ */
+
+function makeSpread(state: Record<string, unknown> = {}) {
+  const next = vi.fn(async () => null);
+  const notify = vi.fn();
+  const app = { next, notify } as any;
+  const service = SpreadDescriptor.create(app, "board", {} as any, "spread-1") as any;
+  service.configure(state);
+  return { service, next, notify };
+}
+
+describe("Spread", () => {
+  it("sends each item on by itself, saying where it sat", async () => {
+    const { service, next } = makeSpread();
+
+    expect(await service.process(["a", "b", "c"])).toBeNull();
+
+    const sent = next.mock.calls.map(([, value]: any[]) => value);
+    expect(sent.map((part: any) => [part.item, part.index, part.total])).toEqual([
+      ["a", 0, 3],
+      ["b", 1, 3],
+      ["c", 2, 3],
+    ]);
+    // One group per array, the same for all of its items.
+    expect(new Set(sent.map((part: any) => part.group)).size).toBe(1);
+  });
+
+  it("gives each array a group of its own", async () => {
+    const { service, next } = makeSpread();
+
+    await service.process(["a"]);
+    await service.process(["b"]);
+
+    const groups = next.mock.calls.map(([, value]: any[]) => value.group);
+    expect(groups[0]).not.toBe(groups[1]);
+  });
+
+  it("treats a single item as an array of one", async () => {
+    const { service, next } = makeSpread();
+
+    await service.process({ x: 1 });
+
+    expect(next.mock.calls.map(([, value]: any[]) => value)).toMatchObject([
+      { item: { x: 1 }, index: 0, total: 1 },
+    ]);
+  });
+
+  it("reaches into a result that says more than the list", async () => {
+    const { service, next } = makeSpread({ itemsFrom: "rows" });
+
+    await service.process({ rows: [1, 2], count: 2 });
+
+    expect(next.mock.calls.map(([, value]: any[]) => value.item)).toEqual([1, 2]);
+  });
+
+  it("sends nothing on for nothing", async () => {
+    const { service, next } = makeSpread();
+
+    expect(await service.process(null)).toBeNull();
+    expect(await service.process([])).toBeNull();
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  it("keeps where its items come from on the board", async () => {
+    const { service, notify } = makeSpread({ itemsFrom: "rows" });
+
+    expect(await service.getConfiguration()).toEqual({ itemsFrom: "rows", bypass: false });
+    expect(notify).toHaveBeenCalledWith(service, { itemsFrom: "rows" });
+  });
+});
+
+describe("Spread in a runtime", () => {
+  it("makes each item a result of its own, in the run that reached it", async () => {
+    const { scope: scope_ } = await api.addRuntime(
+      { name: "Browser", type: "browser" } as any,
+      null,
+      "test-board",
+    );
+    const scope = scope_ as BrowserRuntimeScope;
+    const results: Array<{ result: unknown; context: unknown }> = [];
+    scope.onResult = async (_uuid, result, context) => {
+      results.push({ result, context });
+    };
+    await api.addService(scope, {
+      serviceId: "spread",
+      serviceName: "Spread",
+    } as any);
+    await api.addService(scope, {
+      serviceId: "hookup.to/service/monitor",
+      serviceName: "After",
+    } as any);
+
+    const run = { runId: "run-1", actor: { kind: "board" } } as ProcessContext;
+    await scope.next(null, ["one", "two"], run, false);
+
+    // Two results that go on to the next runtime, then the null the Spread's
+    // own pass ended in, which goes nowhere.
+    expect(results.map((entry) => (entry.result as any)?.item ?? null)).toEqual([
+      "one",
+      "two",
+      null,
+    ]);
+    expect(results.every((entry) => entry.context === run)).toBe(true);
+  });
+});
+
+describe("File Source chunks", () => {
+  it("cuts text into pieces of at most the chunk size, in order", () => {
+    expect(chunkText("abcdefg", 3)).toEqual(["abc", "def", "g"]);
+    expect(chunkText("abc", 10)).toEqual(["abc"]);
+  });
+
+  it("is one empty piece for an empty text, so an empty file still arrives", () => {
+    expect(chunkText("", 3)).toEqual([""]);
+  });
+
+  it("never cuts between the halves of a surrogate pair", () => {
+    const text = "ab😀cd"; // the emoji is two UTF-16 units
+    const chunks = chunkText(text, 3);
+
+    expect(chunks.join("")).toBe(text);
+    expect(chunks).toEqual(["ab", "😀c", "d"]);
+  });
+});