Expose scheduler state and don't enqueue/trigger midi keys when repl stopped

Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1897

packages/core/index.mjs

@@ -22,7 +22,7 @@ export * from './repl.mjs';
 export * from './signal.mjs';
 export * from './speak.mjs';
 export * from './state.mjs';
-export * from './time.mjs';
+export * from './schedulerState.mjs';
 export * from './timespan.mjs';
 export * from './ui.mjs';
 export * from './util.mjs';

packages/core/repl.mjs

@@ -2,7 +2,13 @@ import { NeoCyclist } from './neocyclist.mjs';
 import { Cyclist } from './cyclist.mjs';
 import { evaluate as _evaluate } from './evaluate.mjs';
 import { errorLogger, logger } from './logger.mjs';
-import { setTime } from './time.mjs';
+import {
+  setCpsFunc,
+  setIsStarted,
+  setPattern as exposeSchedulerPattern,
+  setTime,
+  setTriggerFunc,
+} from './schedulerState.mjs';
 import { evalScope } from './evaluate.mjs';
 import { register, Pattern, isPattern, silence, stack } from './pattern.mjs';
 import { reset_state } from './impure.mjs';
@@ -52,6 +58,7 @@ export function repl({
     getTime,
     onToggle: (started) => {
       updateState({ started });
+      setIsStarted(started);
       onToggle?.(started);
       if (!started) {
         reset_state();
@@ -65,6 +72,8 @@ export function repl({
   // NeoCyclist uses a shared worker to communicate between instances, which is not supported on mobile chrome
   const scheduler =
     sync && typeof SharedWorker != 'undefined' ? new NeoCyclist(schedulerOptions) : new Cyclist(schedulerOptions);
+  setTriggerFunc(schedulerOptions.onTrigger);
+  setCpsFunc(() => scheduler.cps);
   let pPatterns = {};
   let anonymousIndex = 0;
   let allTransform;
@@ -89,6 +98,7 @@ export function repl({
   const setPattern = async (pattern, autostart = true) => {
     pattern = editPattern?.(pattern) || pattern;
     await scheduler.setPattern(pattern, autostart);
+    exposeSchedulerPattern(pattern);
     return pattern;
   };
   setTime(() => scheduler.now()); // TODO: refactor?

packages/core/schedulerState.mjs

@@ -0,0 +1,53 @@
+/*
+schedulerState.mjs - Module to pipe out various parameters from the scheduler for global consumption
+Copyright (C) 2026 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/core/schedulerState.mjs>
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+let time;
+let cpsFunc;
+let pattern;
+let triggerFunc;
+let isStarted;
+export function getTime() {
+  if (!time) {
+    throw new Error('no time set! use setTime to define a time source');
+  }
+  return time();
+}
+
+export function setTime(func) {
+  time = func;
+}
+
+export function setCpsFunc(func) {
+  cpsFunc = func;
+}
+
+export function getCps() {
+  return cpsFunc?.();
+}
+
+export function setPattern(pat) {
+  pattern = pat;
+}
+
+export function getPattern() {
+  return pattern;
+}
+
+export function setTriggerFunc(func) {
+  triggerFunc = func;
+}
+
+export function getTriggerFunc() {
+  return triggerFunc;
+}
+
+export function setIsStarted(val) {
+  isStarted = !!val;
+}
+
+export function getIsStarted() {
+  return isStarted;
+}

packages/core/time.mjs

@@ -1,11 +0,0 @@
-let time;
-export function getTime() {
-  if (!time) {
-    throw new Error('no time set! use setTime to define a time source');
-  }
-  return time();
-}
-
-export function setTime(func) {
-  time = func;
-}

packages/midi/midi.mjs

@@ -5,9 +5,23 @@ This program is free software: you can redistribute it and/or modify it under th
 */
 
 import * as _WebMidi from 'webmidi';
-import { Pattern, isPattern, logger, ref } from '@strudel/core';
+import {
+  Hap,
+  Pattern,
+  TimeSpan,
+  getCps,
+  getIsStarted,
+  getPattern,
+  getTime,
+  getTriggerFunc,
+  isPattern,
+  logger,
+  ref,
+  reify,
+} from '@strudel/core';
 import { noteToMidi, getControlName } from '@strudel/core';
 import { Note } from 'webmidi';
+import { getAudioContext } from '@strudel/webaudio';
 import { scheduleAtTime } from '../superdough/helpers.mjs';
 
 // if you use WebMidi from outside of this package, make sure to import that instance:
@@ -477,14 +491,41 @@ Pattern.prototype.midi = function (midiport, options = {}) {
   });
 };
 
-let listeners = {};
-const refs = {};
-const refsByChan = {};
+/**
+ * Initialize a midi device
+ */
+async function _initialize(input) {
+  if (isPattern(input)) {
+    throw new Error(
+      `[midi] Midi input cannot be a pattern. Make sure to pass device name with single quotes. Example: midin('${
+        WebMidi.outputs?.[0]?.name || 'IAC Driver Bus 1'
+      }')`,
+    );
+  }
+  const initial = await enableWebMidi(); // only returns on first init
+  const device = getDevice(input, WebMidi.inputs);
+  if (!device) {
+    throw new Error(
+      `[midi] Midi device "${input}" not found.. connected devices: ${getMidiDeviceNamesString(WebMidi.inputs)}`,
+    );
+  }
+  if (initial) {
+    const otherInputs = WebMidi.inputs.filter((o) => o.name !== device.name);
+    logger(
+      `[midi] Midi enabled! Using "${device.name}". ${
+        otherInputs?.length ? `Also available: ${getMidiDeviceNamesString(otherInputs)}` : ''
+      }`,
+    );
+  }
+  return device;
+}
 
 /**
  * MIDI input: Opens a MIDI input port to receive MIDI control change messages.
  *
  * The output is a function that accepts a midi cc value to query as well as (optionally) a midi channel
+ *
+ * @name midin
  * @param {string | number} input MIDI device name or index defaulting to 0
  * @returns {function(number, number=): Pattern} A function from (cc, channel?) to a pattern.
  *   When queried, the pattern will produces the most recently received midi value (normalized to 0 to 1)
@@ -498,29 +539,11 @@ const refsByChan = {};
  * note("c a f e").s("saw")
  *   .when(cc(0).gt(0), x => x.postgain(0))
  */
+let listeners = {};
+const refs = {};
+const refsByChan = {};
 export async function midin(input) {
-  if (isPattern(input)) {
-    throw new Error(
-      `midin: does not accept Pattern as input. Make sure to pass device name with single quotes. Example: midin('${
-        WebMidi.outputs?.[0]?.name || 'IAC Driver Bus 1'
-      }')`,
-    );
-  }
-  const initial = await enableWebMidi(); // only returns on first init
-  const device = getDevice(input, WebMidi.inputs);
-  if (!device) {
-    throw new Error(
-      `midiin: device "${input}" not found.. connected devices: ${getMidiDeviceNamesString(WebMidi.inputs)}`,
-    );
-  }
-  if (initial) {
-    const otherInputs = WebMidi.inputs.filter((o) => o.name !== device.name);
-    logger(
-      `Midi enabled! Using "${device.name}". ${
-        otherInputs?.length ? `Also available: ${getMidiDeviceNamesString(otherInputs)}` : ''
-      }`,
-    );
-  }
+  const device = await _initialize(input);
   refs[input] ??= {};
   refsByChan[input] ??= {};
   const cc = (cc, chan) => {
@@ -532,8 +555,7 @@ export async function midin(input) {
 
   listeners[input] && device.removeListener('midimessage', listeners[input]);
   listeners[input] = (e) => {
-    const ccNum = e.dataBytes[0];
-    const v = e.dataBytes[1];
+    const [ccNum, v] = e.dataBytes;
     const chan = e.message.channel;
     const scaled = v / 127;
     refsByChan[input][ccNum] ??= {};
@@ -543,3 +565,132 @@ export async function midin(input) {
   device.addListener('midimessage', listeners[input]);
   return cc;
 }
+
+/**
+ * MIDI keyboard: Opens a MIDI input port to receive MIDI keyboard messages.
+ *
+ * The note length is fixed as Superdough is not currently set up for undetermined
+ * note durations
+ *
+ * @name midikeys
+ * @param {string | number} input MIDI device name or index defaulting to 0
+ * @returns {function((number | Pattern)=): Pattern} A function that produces a pattern.
+ *   When queried, the pattern will produces the most recently played midi notes and velocities,
+ *   lasting for the specified duration
+ * @example
+ * const kb = await midikeys('Arturia KeyStep 32')
+ * kb().s("tri").lpf(80).lpe(6).lpd(0.1).room(2).delay(0.35)
+ * @example
+ * const kb = await midikeys('Arturia KeyStep 32')
+ * kb("0.5 1")
+ *   .s("saw")
+ *   .add(note(rand.mul(0.3)))
+ *   .lpf(1000).lpe(2).room(0.5)
+ */
+const kHaps = {};
+const kListeners = {};
+
+function _triggerKeyboard(input, cps, now, latencyCycles) {
+  const pattern = getPattern();
+  const trigger = getTriggerFunc();
+  if (!pattern || !trigger) {
+    return false;
+  }
+  const t = now + latencyCycles;
+  const eps = 1e-6;
+  const haps = pattern.queryArc(t - eps, t + eps, { _cps: cps });
+  // Only keep haps coming from `midikeys`
+  const kbHaps = haps.filter((hap) => hap.value?.midikey?.startsWith(`${input}_`));
+  const ctxNow = getAudioContext().currentTime;
+  if (!kbHaps.length) {
+    return false;
+  }
+  kbHaps.forEach((hap) => {
+    if (!hap.hasOnset()) {
+      return;
+    }
+    const t = ctxNow + (hap.whole.begin - now) / cps;
+    const duration = hap.duration / cps;
+    trigger(hap, t - ctxNow, duration, cps, t);
+  });
+
+  return true;
+}
+export async function midikeys(input) {
+  const device = await _initialize(input);
+  if (!kHaps[input]) {
+    kHaps[input] = [];
+  }
+  kListeners[input] && device.removeListener('midimessage', kListeners[input]);
+  kListeners[input] = (e) => {
+    const { dataBytes, message } = e;
+    const noteon = message.command === 9;
+    let noteoff = message.command === 8;
+    // Don't enqueue or trigger midi notes if scheduler is not started
+    const notStarted = !getIsStarted();
+    // Ignore non-note messages (e.g. CC, pitchbend, modwheel, etc.)
+    const notANote = !noteon && !noteoff;
+    if (notStarted || notANote) {
+      return;
+    }
+    const [note, velocity] = dataBytes;
+    noteoff ||= noteon && velocity === 0; // handle devices which may use velocity = 0 to signal noteoff
+    const key = `${input}_${note}`;
+    const cps = getCps() ?? 0.5;
+    const triggerAvailable = !!(getPattern() && getTriggerFunc());
+    const latencySeconds = triggerAvailable ? 0.01 : 0.06; // avoid missing notes due to cyclist / trigger latency
+    const now = getTime();
+    const t = now + latencySeconds * cps;
+    const span = new TimeSpan(t, t);
+    let value = { midikey: key };
+    if (noteoff) {
+      /* TODO: It's a big effort, but we could modify superdough to allow for situations where
+      we don't know the hap duration in advance. This would mean, for example, that if the hap
+      is flagged as such a special note-on event, we have all effects be persistent & all ADSR
+      envelopes stop at the S stage [and store references to them by `midikey`]
+      If this is implemented, then getting full keyboard functionality should be as simple
+      as sending the corresponding note-off event below and triggering `release` on each of those
+      referenced effects/envelopes
+      
+      value = { ...value, noteoff: true };
+  
+      If this is achieved, we can remove the noteLength parameter
+      */
+      return;
+    } else {
+      value = { ...value, note: Math.round(note), velocity: velocity / 127 };
+    }
+    kHaps[input].push(new Hap(span, span, value, {}));
+    if (!noteoff && triggerAvailable) {
+      // If we have access to a trigger function, we call it to immediately
+      // dispatch to the audio engine, rather than waiting for cyclist to catch these haps
+      const triggered = _triggerKeyboard(input, cps, now, latencySeconds * cps);
+      if (triggered) {
+        kHaps[input] = [];
+      }
+    }
+  };
+  device.addListener('midimessage', kListeners[input]);
+  const kb = (noteLength = 0.5) => {
+    const nlPat = reify(noteLength);
+    const query = (state) => {
+      const haps = kHaps[input].flatMap((hap) => {
+        const lenHaps = nlPat.query(state.setSpan(hap.wholeOrPart()));
+        return lenHaps.map((lenHap) => {
+          const nl = lenHap.value ?? 0.5;
+          const whole = new TimeSpan(hap.whole.begin, hap.whole.begin.add(nl));
+          const part = new TimeSpan(hap.part.begin, hap.part.begin.add(nl));
+          const context = hap.combineContext(lenHap);
+          return new Hap(whole, part, hap.value, context);
+        });
+      });
+      if (state.controls.cyclist) {
+        // Notes have been sent; clear them
+        kHaps[input] = [];
+      }
+      return haps;
+    };
+    return new Pattern(query);
+  };
+  return kb;
+}

packages/superdough/nodePools.mjs

@@ -7,11 +7,13 @@ This program is free software: you can redistribute it and/or modify it under th
 
 const nodePools = new Map();
 const POOL_KEY = Symbol('nodePoolKey');
-const IS_WORKLET_DEAD = Symbol('nodePoolIsWorkletDead');
-const MAX_POOL_SIZE = 64;
 
 export const isPoolable = (node) => !!node[POOL_KEY];
 
+const getNodeTime = (node) => {
+  return node.context?.currentTime ?? 0;
+};
+
 const getParams = (node) => {
   const params = new Set();
   node.parameters?.forEach((param) => params.add(param));
@@ -38,34 +40,43 @@ export const releaseNodeToPool = (node) => {
     // not reusable
     return;
   }
-  if (node[IS_WORKLET_DEAD]) {
-    // Worklet already terminated, don't pool it
-    return;
-  }
   const key = node[POOL_KEY];
   if (key == null) return;
-  const now = node.context?.currentTime ?? 0;
+  const now = getNodeTime(node);
   getParams(node).forEach((param) => param.cancelScheduledValues(now));
   const pool = nodePools.get(key) ?? [];
-  if (pool.length < MAX_POOL_SIZE) {
-    pool.push(new WeakRef(node));
-    nodePools.set(key, pool);
-  }
+  pool.push(new WeakRef(node));
+  nodePools.set(key, pool);
 };
 
-export const markWorkletAsDead = (worklet) => (worklet[IS_WORKLET_DEAD] = true);
+// Audio worklets are given a grace period to survive (`return true`) after
+// being released. This concludes at time `end + 0.5`. We test here whether we are
+// within some safe distance of that (`end + 0.45`) and if so, permit the node to be
+// released. This helps to prevent race conditions between node termination and node
+// re-use
+const isNodeAlive = (node) => {
+  // Skip check if node is not a worklet
+  if (!(node instanceof AudioWorkletNode)) return true;
+  const now = getNodeTime(node);
+  const end = node?.parameters?.get('end').value ?? 0;
+  return now < end + 0.45;
+};
 
 // Attempt to get node from the pool. If this fails, fall back
 // to building it with the factory
 export const getNodeFromPool = (key, factory) => {
   const pool = nodePools.get(key) ?? [];
   let node;
+  let found = false;
   while (pool.length) {
     const ref = pool.pop();
     node = ref?.deref();
-    if (node != null && !node[IS_WORKLET_DEAD]) break;
+    if (node != null && isNodeAlive(node)) {
+      found = true;
+      break;
+    }
   }
-  if (node == null || node[IS_WORKLET_DEAD]) {
+  if (!found) {
     node = factory();
   }
   node[POOL_KEY] = key;

packages/superdough/synth.mjs

@@ -18,7 +18,7 @@ import {
 } from './helpers.mjs';
 import { logger } from './logger.mjs';
 import { getNoiseMix, getNoiseOscillator } from './noise.mjs';
-import { getNodeFromPool, markWorkletAsDead, releaseNodeToPool } from './nodePools.mjs';
+import { getNodeFromPool, releaseNodeToPool } from './nodePools.mjs';
 
 const waveforms = ['triangle', 'square', 'sawtooth', 'sine', 'user', 'one'];
 const waveformAliases = [
@@ -185,10 +185,6 @@ export function registerSynthSounds() {
         param.setValueAtTime(target, now);
       });
       o.port.postMessage({ type: 'initialize' });
-      o.port.onmessage = (e) => {
-        if (e.data.type === 'died') markWorkletAsDead(o);
-        o.port.onmessage = null;
-      };
       const gainAdjustment = 1 / Math.sqrt(voices);
       getPitchEnvelope(o.parameters.get('detune'), value, begin, holdend);
       const vibratoHandle = getVibratoOscillator(o.parameters.get('detune'), value, begin);

packages/superdough/wavetable.mjs

@@ -11,7 +11,7 @@ import {
   webAudioTimeout,
   releaseAudioNode,
 } from './helpers.mjs';
-import { getNodeFromPool, markWorkletAsDead, releaseNodeToPool } from './nodePools.mjs';
+import { getNodeFromPool, releaseNodeToPool } from './nodePools.mjs';
 import { logger } from './logger.mjs';
 
 export const Warpmode = Object.freeze({
@@ -251,10 +251,6 @@ export async function onTriggerSynth(t, value, onended, tables, cps, frameLen) {
     param.setValueAtTime(target, now);
   });
   source.port.postMessage({ type: 'initialize', payload });
-  source.port.onmessage = (e) => {
-    if (e.data.type === 'died') markWorkletAsDead(source);
-    source.port.onmessage = null;
-  };
   if (ac.currentTime > t) {
     logger(`[wavetable] still loading sound "${s}:${n}"`, 'highlight');
     return;

packages/superdough/worklets.mjs

@@ -463,7 +463,6 @@ registerProcessor('distort-processor', DistortProcessor);
 class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
   constructor() {
     super();
-    this.isAlive = true; // used internally to prevent multiple death messages
     this.port.onmessage = (e) => {
       const { type, payload } = e.data || {};
       if (type === 'initialize') {
@@ -479,16 +478,16 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
     return [
       {
         name: 'begin',
-        defaultValue: 0,
+        defaultValue: -1,
         max: Number.POSITIVE_INFINITY,
-        min: 0,
+        min: -1,
       },
 
       {
         name: 'end',
-        defaultValue: 0,
+        defaultValue: -1,
         max: Number.POSITIVE_INFINITY,
-        min: 0,
+        min: -1,
       },
 
       {
@@ -523,16 +522,17 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
     ];
   }
   process(_input, outputs, params) {
-    if (currentTime >= params.end[0] + 0.5) {
-      // Outside of grace period - should terminate
-      if (this.isAlive) {
-        this.port.postMessage({ type: 'died' });
-        this.isAlive = false;
-      }
+    const begin = params.begin[0];
+    const end = params.end[0];
+    const beginDefined = begin >= 0;
+    const endDefined = end >= 0;
+    // We give a 0.5s grace period (for node pooling) before termination
+    const shouldTerminate = endDefined && currentTime >= end + 0.5;
+    const ended = endDefined && currentTime >= end;
+    const notStarted = currentTime <= begin;
+    if (shouldTerminate) {
       return false;
-    }
-    if (currentTime >= params.end[0] || currentTime <= params.begin[0]) {
-      // Inside of grace period or not yet started
+    } else if (ended || notStarted || !beginDefined) {
       return true;
     }
     const output = outputs[0];
@@ -1148,8 +1148,8 @@ const tablesCache = {};
 class WavetableOscillatorProcessor extends AudioWorkletProcessor {
   static get parameterDescriptors() {
     return [
-      { name: 'begin', defaultValue: 0, min: 0, max: Number.POSITIVE_INFINITY },
-      { name: 'end', defaultValue: 0, min: 0, max: Number.POSITIVE_INFINITY },
+      { name: 'begin', defaultValue: -1, min: -1, max: Number.POSITIVE_INFINITY },
+      { name: 'end', defaultValue: -1, min: -1, max: Number.POSITIVE_INFINITY },
       { name: 'frequency', defaultValue: 440, min: Number.EPSILON },
       { name: 'detune', defaultValue: 0 },
       { name: 'freqspread', defaultValue: 0.18, min: 0 },
@@ -1164,7 +1164,6 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
 
   constructor(options) {
     super(options);
-    this.isAlive = true; // used internally to prevent multiple death messages
     this.port.onmessage = (e) => {
       const { type, payload } = e.data || {};
       if (type === 'initialize') {
@@ -1332,16 +1331,17 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
   }
 
   process(_inputs, outputs, parameters) {
-    if (currentTime >= parameters.end[0] + 0.5) {
-      // Outside of grace period - should terminate
-      if (this.isAlive) {
-        this.port.postMessage({ type: 'died' });
-        this.isAlive = false;
-      }
+    const begin = parameters.begin[0];
+    const end = parameters.end[0];
+    const beginDefined = begin >= 0;
+    const endDefined = end >= 0;
+    // We give a 0.5s grace period (for node pooling) before termination
+    const shouldTerminate = endDefined && currentTime >= end + 0.5;
+    const ended = endDefined && currentTime >= end;
+    const notStarted = currentTime <= begin;
+    if (shouldTerminate) {
       return false;
-    }
-    if (currentTime >= parameters.end[0] || currentTime <= parameters.begin[0]) {
-      // Inside of grace period or not yet started
+    } else if (ended || notStarted || !beginDefined) {
       return true;
     }
     const outL = outputs[0][0];

test/__snapshots__/examples.test.mjs.snap

@@ -7241,6 +7241,10 @@ exports[`runs examples > example "midicmd" example index 0 1`] = `
 ]
 `;
 
+exports[`runs examples > example "midikeys" example index 0 1`] = `[]`;
+
+exports[`runs examples > example "midikeys" example index 1 1`] = `[]`;
+
 exports[`runs examples > example "midin" example index 0 1`] = `
 [
   "[ 0/1 → 1/4 | note:c cutoff:0 resonance:0 s:sawtooth ]",

test/runtime.mjs

@@ -131,6 +131,10 @@ const midin = () => {
   return (ccNum) => strudel.ref(() => 0); // returns ref with default value 0
 };
 
+const midikeys = async () => {
+  return () => strudel.silence;
+};
+
 const sysex = ([id, data]) => {};
 
 // TODO: refactor to evalScope
@@ -150,6 +154,7 @@ evalScope(
   */
   {
     midin,
+    midikeys,
     sysex,
     // gist,
     // euclid,

website/src/metadata_parser.js

@@ -1,4 +1,4 @@
-const ALLOW_MANY = ['by', 'url', 'genre', 'license'];
+const ALLOW_MANY = ['by', 'url', 'genre', 'license', 'tag'];
 
 export function getMetadata(raw_code) {
   if (raw_code == null) {

website/src/pages/learn/input-output.mdx

@@ -16,10 +16,14 @@ It is also possible to pattern other things with Strudel, such as software and h
 
 Strudel supports MIDI without any additional software (thanks to [webmidi](https://npmjs.com/package/webmidi)), just by adding methods to your pattern:
 
-## midiin(inputName?)
+## midin(inputName?)
 
 <JsDoc client:idle name="midin" h={0} />
 
+## midikeys(inputName?)
+
+<JsDoc client:idle name="midikeys" h={0} />
+
 ## midi(outputName?,options?)
 
 Either connect a midi device or use the IAC Driver (Mac) or Midi Through Port (Linux) for internal midi messages.

website/src/repl/components/panel/PatternsTab.jsx

@@ -18,6 +18,7 @@ import { Pagination } from '../pagination/Pagination.jsx';
 import { useState } from 'react';
 import { useDebounce } from '../usedebounce.jsx';
 import cx from '@src/cx.mjs';
+import { Textbox } from '../textbox/Textbox.jsx';
 
 export function PatternLabel({ pattern } /* : { pattern: Tables<'code'> } */) {
   const meta = useMemo(() => getMetadata(pattern.code), [pattern]);
@@ -28,12 +29,12 @@ export function PatternLabel({ pattern } /* : { pattern: Tables<'code'> } */) {
     if (!isNaN(date)) {
       title = date.toLocaleDateString();
     } else {
-      title = 'unnamed';
+      title = pattern.id || 'unnamed';
     }
   }
 
   const author = Array.isArray(meta.by) ? meta.by.join(',') : 'Anonymous';
-  return <>{`${pattern.id}: ${title} by ${author.slice(0, 100)}`.slice(0, 60)}</>;
+  return <>{`${title} by ${author.slice(0, 100)}`.slice(0, 60)}</>;
 }
 
 function PatternButton({ showOutline, onClick, pattern, showHiglight }) {
@@ -79,73 +80,115 @@ const updateCodeWindow = (context, patternData, reset = false) => {
   context.handleUpdate(patternData, reset);
 };
 
-function UserPatterns({ context }) {
+export function PatternsTab({ context }) {
+  const [search, setSearch] = useState('');
   const activePattern = useActivePattern();
   const viewingPatternStore = useViewingPatternData();
   const viewingPatternData = parseJSON(viewingPatternStore);
-  const { userPatterns, patternFilter, patternAutoStart } = useSettings();
+  const { userPatterns, patternAutoStart } = useSettings();
   const viewingPatternID = viewingPatternData?.id;
-  return (
-    <div className="flex flex-col gap-2 flex-grow overflow-hidden h-full pb-2 ">
-      <div className="pr-4 space-x-4  flex max-w-full overflow-x-auto">
-        <ActionButton
-          label="new"
-          onClick={() => {
-            const { data } = userPattern.createAndAddToDB();
-            updateCodeWindow(context, data);
-          }}
-        />
-        <ActionButton
-          label="duplicate"
-          onClick={() => {
-            const { data } = userPattern.duplicate(viewingPatternData);
-            updateCodeWindow(context, data);
-          }}
-        />
-        <ActionButton
-          label="delete"
-          onClick={() => {
-            const { data } = userPattern.delete(viewingPatternID);
-            updateCodeWindow(context, { ...data, collection: userPattern.collection });
-          }}
-        />
-        <label className="hover:opacity-50 cursor-pointer">
-          <input
-            style={{ display: 'none' }}
-            type="file"
-            multiple
-            accept="text/plain,text/x-markdown,application/json"
-            onChange={(e) => importPatterns(e.target.files)}
-          />
-          import
-        </label>
-        <ActionButton label="export" onClick={exportPatterns} />
 
-        <ActionButton
-          label="delete-all"
-          onClick={() => {
-            const { data } = userPattern.clearAll();
-            updateCodeWindow(context, data);
-          }}
-        />
-      </div>
+  const visiblePatterns = useMemo(() => {
+    if (!search) {
+      return userPatterns;
+    }
+    return Object.fromEntries(
+      Object.entries(userPatterns).filter(([_key, pattern]) => {
+        const meta = getMetadata(pattern.code);
 
-      <div className="overflow-auto h-full bg-background p-2 rounded-md">
-        {/* {patternFilter === patternFilterName.user && ( */}
-        <PatternButtons
-          onClick={(id) => {
-            updateCodeWindow(context, { ...userPatterns[id], collection: userPattern.collection }, patternAutoStart);
-
-            if (context.started && activePattern === id) {
-              context.handleEvaluate();
+        // Search for specific meta keys
+        const searchLowercaseTrimmed = search.trim().toLowerCase();
+        if (searchLowercaseTrimmed.includes(':')) {
+          const [metaKey, metaSearch] = searchLowercaseTrimmed.split(/:\s*/);
+          if (metaKey !== undefined && metaSearch !== undefined && metaKey in meta) {
+            const metaValues = meta[metaKey];
+            if (Array.isArray(metaValues)) {
+              return metaValues.some((metaValue) => metaValue.toLowerCase().includes(metaSearch));
+            } else if (typeof metaValues === 'string') {
+              return metaValues.toLowerCase().includes(metaSearch);
+            } else {
+              return false;
             }
-          }}
-          patterns={userPatterns}
-          started={context.started}
-          activePattern={activePattern}
-          viewingPatternID={viewingPatternID}
-        />
-        {/* )} */}
+          }
+        }
+        const title = meta.title ? meta.title : 'unnamed';
+        const authors = meta.by ? meta.by : ['anonymous'];
+        const tags = meta.tag ? meta.tag : [];
+        return (
+          title.toLowerCase().includes(searchLowercaseTrimmed) ||
+          authors.some((author) => author.toLowerCase().includes(searchLowercaseTrimmed)) ||
+          tags.some((tag) => tag.toLowerCase().includes(searchLowercaseTrimmed))
+        );
+      }),
+    );
+  }, [search, viewingPatternStore]);
+
+  return (
+    <div className="px-4 w-full text-foreground  space-y-2  flex flex-col overflow-hidden max-h-full h-full">
+      <div className="w-full flex">
+        <Textbox className="w-full" placeholder="Search" value={search} onChange={setSearch} />
+      </div>
+      <div className="flex flex-col gap-2 flex-grow overflow-hidden h-full pb-2 ">
+        <div className="pr-4 space-x-4  flex max-w-full overflow-x-auto">
+          <ActionButton
+            label="new"
+            onClick={() => {
+              const { data } = userPattern.createAndAddToDB();
+              updateCodeWindow(context, data);
+            }}
+          />
+          <ActionButton
+            label="duplicate"
+            onClick={() => {
+              const { data } = userPattern.duplicate(viewingPatternData);
+              updateCodeWindow(context, data);
+            }}
+          />
+          <ActionButton
+            label="delete"
+            onClick={() => {
+              const { data } = userPattern.delete(viewingPatternID);
+              updateCodeWindow(context, { ...data, collection: userPattern.collection });
+            }}
+          />
+          <label className="hover:opacity-50 cursor-pointer">
+            <input
+              style={{ display: 'none' }}
+              type="file"
+              multiple
+              accept="text/plain,text/x-markdown,application/json"
+              onChange={(e) => importPatterns(e.target.files)}
+            />
+            import
+          </label>
+          <ActionButton label="export" onClick={exportPatterns} />
+
+          <ActionButton
+            label="delete-all"
+            onClick={() => {
+              const { data } = userPattern.clearAll();
+              updateCodeWindow(context, data);
+            }}
+          />
+        </div>
+
+        <div className="overflow-auto h-full bg-background p-2 rounded-md">
+          {/* {patternFilter === patternFilterName.user && ( */}
+          <PatternButtons
+            onClick={(id) => {
+              updateCodeWindow(context, { ...userPatterns[id], collection: userPattern.collection }, patternAutoStart);
+
+              if (context.started && activePattern === id) {
+                context.handleEvaluate();
+              }
+            }}
+            patterns={visiblePatterns}
+            started={context.started}
+            activePattern={activePattern}
+            viewingPatternID={viewingPatternID}
+          />
+          {/* )} */}
+        </div>
       </div>
     </div>
   );
@@ -232,28 +275,3 @@ function PublicPatterns({ context }) {
   }
   return <LatestPatterns context={context} />;
 }
-
-export function PatternsTab({ context }) {
-  const { patternFilter } = useSettings();
-
-  return (
-    <div className="px-4 w-full text-foreground  space-y-2  flex flex-col overflow-hidden max-h-full h-full">
-      <UserPatterns context={context} />
-    </div>
-  );
-  /* return (
-    <div className="px-4 w-full text-foreground  space-y-2  flex flex-col overflow-hidden max-h-full h-full">
-      <ButtonGroup
-        value={patternFilter}
-        onChange={(value) => settingsMap.setKey('patternFilter', value)}
-        items={patternFilterName}
-      ></ButtonGroup>
-
-      {patternFilter === patternFilterName.user ? (
-        <UserPatterns context={context} />
-      ) : (
-        <PublicPatterns context={context} />
-      )}
-    </div>
-  ); */
-}

website/src/repl/components/panel/Reference.jsx

@@ -55,7 +55,7 @@ export function Reference() {
   return (
     <div className="flex h-full w-full p-2 overflow-hidden">
       <div className="h-full  flex flex-col gap-2 w-1/3 max-w-72 ">
-        <div class="w-full flex">
+        <div className="w-full flex">
           <Textbox className="w-full" placeholder="Search" value={search} onChange={setSearch} />
         </div>
         <div className="flex flex-col h-full overflow-y-auto  gap-1.5 bg-background bg-opacity-50  rounded-md">