@stinkycomputing/sesame-snigel-plugin 1.0.0

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@stinkycomputing/sesame-snigel-plugin",
+  "version": "1.0.0",
+  "description": "Snigel replay plugin for the Sesame config editor",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@stinkycomputing/sesame-editor-api": "1.0.0-alpha.5",
+    "@xyflow/react": "^12.10.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.4"
+  }
+}

package/src/config-serializer.ts

@@ -0,0 +1,103 @@
+/**
+ * Snigel plugin – serializeNodes() implementation.
+ *
+ * Serializes snigel/control nodes (and their connected snigel/output and
+ * snigel/super-source children) into the extensions.snigel array.
+ */
+
+import type { MinimalNode, MinimalEdge } from '@stinkycomputing/sesame-editor-api';
+import {
+  getData,
+  nodeProps,
+  nodeMeta,
+  findSourceConnection,
+  getNodesByCategory,
+} from '@stinkycomputing/sesame-editor-api';
+
+export function serializeSnigelNodes<TNode extends MinimalNode, TEdge extends MinimalEdge>(
+  allNodes: TNode[],
+  allEdges: TEdge[],
+): Record<string, unknown> {
+  const snigels: unknown[] = [];
+
+  getNodesByCategory(allNodes, 'snigel').forEach(snigelNode => {
+    const serialized = serializeSnigel(snigelNode, allEdges, allNodes);
+    if (serialized) snigels.push({ ...serialized, _meta: nodeMeta(snigelNode) });
+  });
+
+  if (snigels.length === 0) return {};
+  return { snigel: snigels };
+}
+
+function serializeSnigel<TNode extends MinimalNode, TEdge extends MinimalEdge>(
+  node: TNode,
+  edges: TEdge[],
+  nodes: TNode[],
+): Record<string, unknown> | undefined {
+  const p = nodeProps(node);
+  const d = getData(node);
+  const inputs = d.dynamicInputs ?? d.def.inputs;
+  const nodeOutputs = d.dynamicOutputs ?? d.def.outputs;
+
+  // Collect sources
+  const snSources: unknown[] = [];
+  inputs.forEach((port, i) => {
+    if (port.type !== 'source/device') return;
+    const conn = findSourceConnection(edges, nodes, node.id, `in-${i}`);
+    if (!conn) return;
+    const connData = getData(conn.node);
+    if (connData.def.category === 'snigel-super') {
+      snSources.push(serializeSnigelSuperSource(conn.node, edges, nodes));
+    } else {
+      snSources.push(conn.connectionId);
+    }
+  });
+
+  // Collect outputs (snigel/output nodes)
+  const snOutputs: unknown[] = [];
+  nodeOutputs.forEach((_port, i) => {
+    const outEdge = edges.find(e => e.source === node.id && e.sourceHandle === `out-${i}`);
+    if (!outEdge) return;
+    const outNode = nodes.find(n => n.id === outEdge.target);
+    if (!outNode) return;
+    const op = nodeProps(outNode);
+    snOutputs.push({ id: op.id, type: op.type, video: {}, _meta: nodeMeta(outNode) });
+  });
+
+  const codecMap: Record<string, string> = {
+    h264: 'low_latency',
+    hevc: 'low_latency_hevc',
+    av1: 'low_latency_av1',
+  };
+
+  return {
+    id: p.id,
+    controllerPort: p.controllerPort,
+    sizeGb: p.sizeGb,
+    videoFilePath: p.videoFilePath,
+    ingestFolder: p.ingestFolder,
+    egressFolder: p.egressFolder,
+    video: { encoder: { bitrateKbs: p.bitrate, preset: codecMap[String(p.codec)] || 'low_latency_hevc' } },
+    sources: snSources,
+    outputs: snOutputs,
+  };
+}
+
+function serializeSnigelSuperSource<TNode extends MinimalNode, TEdge extends MinimalEdge>(
+  node: TNode,
+  edges: TEdge[],
+  nodes: TNode[],
+): Record<string, unknown> {
+  const p = nodeProps(node);
+  const d = getData(node);
+  const inputs = d.dynamicInputs ?? d.def.inputs;
+  const srcs: string[] = [];
+
+  inputs.forEach((port, i) => {
+    if (port.type !== 'source/device') return;
+    const conn = findSourceConnection(edges, nodes, node.id, `in-${i}`);
+    if (conn) srcs.push(String(getData(conn.node).properties.id));
+  });
+
+  return { id: p.id, type: 'super', sources: srcs, _meta: nodeMeta(node) };
+}

package/src/graph-builder.ts

@@ -0,0 +1,171 @@
+/**
+ * Snigel plugin – buildNodes() implementation.
+ *
+ * Creates snigel/control, snigel/output, and snigel/super-source nodes from
+ * config, wires internal edges, and returns snigel-output nodes as
+ * supplementalNodes so the core graph-builder can wire them to outputs/RTT.
+ */
+
+import type { Node, Edge } from '@xyflow/react';
+import type { NodeFactory, CoreNodeMaps, PluginBuildResult, ISesameConfig } from '@stinkycomputing/sesame-editor-api';
+import type { ISnigel, ISuperSlowSnigelSource } from './types';
+import { snigelControlDef } from './node-defs';
+
+function presetToCodec(preset: string | undefined): string {
+  if (!preset) return 'hevc';
+  if (preset.includes('hevc')) return 'hevc';
+  if (preset.includes('av1')) return 'av1';
+  return 'h264';
+}
+
+export function buildSnigelNodes(
+  extensions: Record<string, unknown>,
+  config: ISesameConfig,
+  factory: NodeFactory<Node, Edge>,
+  coreNodes: CoreNodeMaps<Node>,
+): PluginBuildResult<Node, Edge> {
+  const nodes: Node[] = [];
+  const edges: Edge[] = [];
+  const supplementalNodes = new Map<string, Node>();
+
+  // Support both new format (extensions.snigel) and legacy (config.snigels)
+  const snigels = (
+    (extensions['snigel'] as ISnigel[] | undefined) ??
+    ((config as unknown as Record<string, unknown>)['snigels'] as ISnigel[] | undefined) ??
+    []
+  );
+
+  const { sourceNodes } = coreNodes;
+  const snigelNodes = new Map<string, Node>();
+  const snigelSuperNodes = new Map<string, Node>();
+
+  let x = factory.X_OFFSET * 6; // position after core columns
+
+  snigels.forEach((snigel, idx) => {
+    const snigelOutputTemplate = snigelControlDef.outputs[0];
+
+    const dynamicInputs = snigel.sources.map((_, i) => ({
+      label: `Source ${i + 1}`, type: 'source/device' as const,
+    }));
+    dynamicInputs.push({ label: `Source ${dynamicInputs.length + 1}`, type: 'source/device' });
+
+    const snigelOutputsList = snigel.outputs?.length
+      ? snigel.outputs
+      : [{ id: `${snigel.id}-out1`, video: {}, type: 'pvw' as const }];
+
+    const dynamicOutputs = snigelOutputsList.map((_, i) => ({
+      label: `Output ${i + 1}`,
+      type: 'source/snigel',
+      maxConnections: snigelOutputTemplate?.maxConnections,
+    }));
+    dynamicOutputs.push({
+      label: `Output ${dynamicOutputs.length + 1}`,
+      type: 'source/snigel',
+      maxConnections: snigelOutputTemplate?.maxConnections,
+    });
+
+    const snigelNode = factory.makeNode(
+      snigel.id,
+      'snigel/control',
+      factory.pos(snigel, x, idx),
+      {
+        id: snigel.id,
+        controllerPort: snigel.controllerPort,
+        sizeGb: snigel.sizeGb,
+        bitrate: snigel.video?.encoder?.bitrateKbs ?? 50000,
+        codec: presetToCodec(snigel.video?.encoder?.preset),
+        videoFilePath: snigel.videoFilePath,
+        ingestFolder: snigel.ingestFolder ?? '',
+        egressFolder: snigel.egressFolder ?? '',
+      },
+      factory.collapsed(snigel),
+      dynamicInputs,
+      dynamicOutputs,
+    );
+    nodes.push(snigelNode);
+    snigelNodes.set(snigel.id, snigelNode);
+
+    // Snigel outputs
+    snigelOutputsList.forEach((sOut, oIdx) => {
+      const outNode = factory.makeNode(
+        sOut.id,
+        'snigel/output',
+        factory.pos(sOut, x + factory.X_OFFSET, idx + oIdx),
+        { id: sOut.id, type: sOut.type },
+        factory.collapsed(sOut),
+      );
+      nodes.push(outNode);
+      supplementalNodes.set(sOut.id, outNode);
+
+      // snigel/control → snigel/output
+      edges.push(factory.edge(snigelNode.id, `out-${oIdx}`, outNode.id, 'in-0'));
+    });
+
+    // Snigel super-sources
+    snigel.sources
+      .filter((s): s is ISuperSlowSnigelSource => typeof s === 'object' && (s as ISuperSlowSnigelSource).type === 'super')
+      .forEach(ss => {
+        const dynamicSSInputs = ss.sources.map((_, i) => ({
+          label: `Source ${i + 1}`, type: 'source/device' as const,
+        }));
+        dynamicSSInputs.push({ label: `Source ${dynamicSSInputs.length + 1}`, type: 'source/device' });
+
+        const ssNode = factory.makeNode(
+          ss.id,
+          'snigel/super-source',
+          factory.pos(ss, x - factory.X_OFFSET, idx),
+          { id: ss.id },
+          factory.collapsed(ss),
+          dynamicSSInputs,
+        );
+        nodes.push(ssNode);
+        snigelSuperNodes.set(ss.id, ssNode);
+      });
+  });
+
+  // ── Snigel ← sources edges ────────────────────────────────────────────
+  // Build these after all nodes exist so findOutputSlot can search them.
+  const allNodes = [...nodes]; // plugin nodes only; coreNodes passed via sourceNodes map
+
+  snigels.forEach(snigel => {
+    const snigelNode = snigelNodes.get(snigel.id);
+    if (!snigelNode) return;
+
+    snigel.sources.forEach((src, srcIdx) => {
+      if (typeof src === 'string') {
+        const slashIdx = src.indexOf('/');
+        const configId = slashIdx >= 0 ? src.slice(0, slashIdx) : src;
+        const outputName = slashIdx >= 0 ? src.slice(slashIdx) : undefined;
+        const srcNode = sourceNodes.get(configId);
+        if (srcNode) {
+          // We need to search core + plugin nodes for the slot
+          const combinedNodes = [...(Array.from(sourceNodes.values())), ...allNodes];
+          const srcSlot = factory.findOutputSlot(combinedNodes, srcNode.id, 'source/device', outputName);
+          if (srcSlot) edges.push(factory.edge(srcNode.id, srcSlot, snigelNode.id, `in-${srcIdx}`));
+        }
+      } else if (src.type === 'super') {
+        const ss = src as ISuperSlowSnigelSource;
+        const ssNode = snigelSuperNodes.get(ss.id);
+        if (ssNode) {
+          const combinedNodes = [...(Array.from(sourceNodes.values())), ...allNodes];
+          const srcSlot = factory.findOutputSlot(combinedNodes, ssNode.id, 'source/device');
+          if (srcSlot) edges.push(factory.edge(ssNode.id, srcSlot, snigelNode.id, `in-${srcIdx}`));
+
+          // Super-source ← core sources
+          ss.sources.forEach((innerSrc, innerIdx) => {
+            const slashIdx = innerSrc.indexOf('/');
+            const configId = slashIdx >= 0 ? innerSrc.slice(0, slashIdx) : innerSrc;
+            const outputName = slashIdx >= 0 ? innerSrc.slice(slashIdx) : undefined;
+            const innerNode = sourceNodes.get(configId);
+            if (innerNode) {
+              const slot = factory.findOutputSlot(combinedNodes, innerNode.id, 'source/device', outputName);
+              if (slot) edges.push(factory.edge(innerNode.id, slot, ssNode.id, `in-${innerIdx}`));
+            }
+          });
+        }
+      }
+    });
+  });
+
+  return { nodes, edges, supplementalNodes };
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Snigel config editor plugin.
+ *
+ * Register this with the Sesame config editor at startup:
+ *
+ *   import { SnigelPlugin } from '@stinkycomputing/sesame-snigel-plugin';
+ *   import { registerPlugin } from './plugins';
+ *   registerPlugin(SnigelPlugin);
+ */
+
+import type { Node, Edge } from '@xyflow/react';
+import type { ISesameEditorPlugin } from '@stinkycomputing/sesame-editor-api';
+import { snigelControlDef, snigelOutputDef, snigelSuperSourceDef } from './node-defs';
+import { buildSnigelNodes } from './graph-builder';
+import { serializeSnigelNodes } from './config-serializer';
+
+export const SnigelPlugin: ISesameEditorPlugin<Node, Edge> = {
+  id: 'com.stinkycomputing.snigel',
+
+  nodeTypes: [snigelControlDef, snigelOutputDef, snigelSuperSourceDef],
+
+  buildNodes: buildSnigelNodes,
+
+  serializeNodes: serializeSnigelNodes,
+};
+
+export * from './types';

package/src/node-defs.ts

@@ -0,0 +1,94 @@
+/** Node type definitions for all three Snigel node types. */
+
+import type { NodeTypeDef, MetadataDef } from '@stinkycomputing/sesame-editor-api';
+
+export const snigelStateMetadata: MetadataDef = {
+  id: 'snigel.jlc.state.v1',
+  label: 'Remote Control State',
+  direction: 'emit',
+  portType: 'metadata/snigel-state',
+  format: 'binary',
+};
+
+export const snigelCommandsMetadata: MetadataDef = {
+  id: 'snigel.jlc.commands.v1',
+  label: 'Remote Control Commands',
+  direction: 'receive',
+  portType: 'metadata/snigel-commands',
+  format: 'binary',
+};
+
+export const snigelColor = '#784212';
+
+export const snigelControlDef: NodeTypeDef = {
+  type: 'snigel/control',
+  title: 'Snigel Replay',
+  category: 'snigel',
+  menuGroup: 'Snigel',
+  menuOrder: 7,
+  menuItemOrder: -1,
+  color: snigelColor,
+  inputs: [
+    { label: 'Source 1', type: 'source/device' },
+  ],
+  outputs: [
+    { label: 'Output 1', type: 'source/snigel', maxConnections: 1 },
+  ],
+  widgets: [
+    { type: 'number', label: 'Size (GB)', property: 'sizeGb', options: { min: 0, max: 1000, step: 1, precision: 0 } },
+    { type: 'text', label: 'Port', property: 'controllerPort' },
+    { type: 'text', label: 'Video folder', property: 'videoFilePath' },
+    { type: 'text', label: 'Ingest folder', property: 'ingestFolder' },
+    { type: 'text', label: 'Egress folder', property: 'egressFolder' },
+    { type: 'combo', label: 'Codec', property: 'codec', options: { values: ['h264', 'hevc', 'av1'] } },
+    { type: 'number', label: 'Bitrate', property: 'bitrate', options: { min: 0, max: 10000000, step: 1000, precision: 0 } },
+  ],
+  defaultProperties: { id: '', controllerPort: 'COM1', videoFilePath: '', ingestFolder: '', egressFolder: '', sizeGb: 1, bitrate: 50000, codec: 'hevc' },
+  dynamicPorts: true,
+  metadata: [snigelStateMetadata, snigelCommandsMetadata],
+};
+
+export const snigelOutputDef: NodeTypeDef = {
+  type: 'snigel/output',
+  title: 'Snigel Output',
+  category: 'snigel-output',
+  menuGroup: 'Snigel',
+  menuOrder: 7,
+  color: snigelColor,
+  inputs: [
+    { label: 'Source', type: 'source/snigel' },
+  ],
+  outputs: [
+    { label: 'Video', type: 'video/composition', name: '/compositor' },
+    { label: 'Audio 1+2', type: 'audio/stereo', name: '/audio_mixer_0' },
+    { label: 'Audio 3+4', type: 'audio/stereo', name: '/audio_mixer_1' },
+    { label: 'Audio 5+6', type: 'audio/stereo', name: '/audio_mixer_2' },
+    { label: 'Audio 7+8', type: 'audio/stereo', name: '/audio_mixer_3' },
+    { label: 'Audio Bus 1+2', type: 'audio/raw', name: '/audio_mixer_0' },
+    { label: 'Audio Bus 3+4', type: 'audio/raw', name: '/audio_mixer_1' },
+    { label: 'Audio Bus 5+6', type: 'audio/raw', name: '/audio_mixer_2' },
+    { label: 'Audio Bus 7+8', type: 'audio/raw', name: '/audio_mixer_3' },
+  ],
+  widgets: [
+    { type: 'combo', label: 'Type', property: 'type', options: { values: ['pvw', 'pgm'] } },
+  ],
+  defaultProperties: { id: '', type: 'pgm' },
+};
+
+export const snigelSuperSourceDef: NodeTypeDef = {
+  type: 'snigel/super-source',
+  title: 'Snigel Super Slow',
+  category: 'snigel-super',
+  menuGroup: 'Snigel',
+  menuOrder: 7,
+  color: snigelColor,
+  inputs: [
+    { label: 'Source 1', type: 'source/device' },
+  ],
+  outputs: [
+    { label: 'Source', type: 'source/device' },
+  ],
+  widgets: [],
+  defaultProperties: { id: '' },
+  dynamicPorts: true,
+};

package/src/types.ts

@@ -0,0 +1,32 @@
+/** Snigel-specific config types (formerly in sesame-interop). */
+
+export interface ISuperSlowSnigelSource {
+  id: string;
+  type: 'super';
+  sources: string[];
+}
+
+export interface ISnigel {
+  id: string;
+  sources: (string | ISuperSlowSnigelSource)[];
+  sizeGb: number;
+  videoFilePath: string;
+  ingestFolder: string;
+  egressFolder: string;
+  video: {
+    encoder?: {
+      preset?: string;
+      bitrateKbs?: number;
+    };
+  };
+  controllerPort: string;
+  outputs: ISnigelOutput[];
+}
+
+export type SnigelOutputType = 'pgm' | 'pvw';
+
+export interface ISnigelOutput {
+  id: string;
+  type: SnigelOutputType;
+  video: Record<string, unknown>;
+}