@stinkycomputing/sesame-snigel-plugin 1.0.0 → 1.0.1

package/dist/config-serializer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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';
+export declare function serializeSnigelNodes<TNode extends MinimalNode, TEdge extends MinimalEdge>(allNodes: TNode[], allEdges: TEdge[]): Record<string, unknown>;

package/dist/config-serializer.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Snigel plugin – serializeNodes() implementation.
+ *
+ * Serializes snigel/control nodes (and their connected snigel/output and
+ * snigel/super-source children) into the extensions.snigel array.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeSnigelNodes = serializeSnigelNodes;
+const sesame_editor_api_1 = require("@stinkycomputing/sesame-editor-api");
+function serializeSnigelNodes(allNodes, allEdges) {
+    const snigels = [];
+    (0, sesame_editor_api_1.getNodesByCategory)(allNodes, 'snigel').forEach(snigelNode => {
+        const serialized = serializeSnigel(snigelNode, allEdges, allNodes);
+        if (serialized)
+            snigels.push({ ...serialized, _meta: (0, sesame_editor_api_1.nodeMeta)(snigelNode) });
+    });
+    if (snigels.length === 0)
+        return {};
+    return { snigel: snigels };
+}
+function serializeSnigel(node, edges, nodes) {
+    const p = (0, sesame_editor_api_1.nodeProps)(node);
+    const d = (0, sesame_editor_api_1.getData)(node);
+    const inputs = d.dynamicInputs ?? d.def.inputs;
+    const nodeOutputs = d.dynamicOutputs ?? d.def.outputs;
+    // Collect sources
+    const snSources = [];
+    inputs.forEach((port, i) => {
+        if (port.type !== 'source/device')
+            return;
+        const conn = (0, sesame_editor_api_1.findSourceConnection)(edges, nodes, node.id, `in-${i}`);
+        if (!conn)
+            return;
+        const connData = (0, sesame_editor_api_1.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 = [];
+    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 = (0, sesame_editor_api_1.nodeProps)(outNode);
+        snOutputs.push({ id: op.id, type: op.type, video: {}, _meta: (0, sesame_editor_api_1.nodeMeta)(outNode) });
+    });
+    return {
+        id: p.id,
+        controllerPort: p.controllerPort,
+        sizeGb: p.sizeGb,
+        videoFilePath: p.videoFilePath,
+        ingestFolder: p.ingestFolder,
+        egressFolder: p.egressFolder,
+        video: { encoder: { bitrateKbs: p.bitrate, codec: p.codec || 'hevc' } },
+        sources: snSources,
+        outputs: snOutputs,
+    };
+}
+function serializeSnigelSuperSource(node, edges, nodes) {
+    const p = (0, sesame_editor_api_1.nodeProps)(node);
+    const d = (0, sesame_editor_api_1.getData)(node);
+    const inputs = d.dynamicInputs ?? d.def.inputs;
+    const srcs = [];
+    inputs.forEach((port, i) => {
+        if (port.type !== 'source/device')
+            return;
+        const conn = (0, sesame_editor_api_1.findSourceConnection)(edges, nodes, node.id, `in-${i}`);
+        if (conn)
+            srcs.push(conn.connectionId);
+    });
+    return { id: p.id, type: 'super', sources: srcs, _meta: (0, sesame_editor_api_1.nodeMeta)(node) };
+}

package/dist/graph-builder.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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';
+export declare function buildSnigelNodes(extensions: Record<string, unknown>, config: ISesameConfig, factory: NodeFactory<Node, Edge>, coreNodes: CoreNodeMaps<Node>): PluginBuildResult<Node, Edge>;

package/dist/graph-builder.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSnigelNodes = buildSnigelNodes;
+const node_defs_1 = require("./node-defs");
+function codecToEditorValue(codec) {
+    if (!codec)
+        return 'hevc';
+    return codec;
+}
+function buildSnigelNodes(extensions, config, factory, coreNodes) {
+    const nodes = [];
+    const edges = [];
+    const supplementalNodes = new Map();
+    // Support both new format (extensions.snigel) and legacy (config.snigels)
+    const snigels = (extensions['snigel'] ??
+        config['snigels'] ??
+        []);
+    const { sourceNodes } = coreNodes;
+    const snigelNodes = new Map();
+    const snigelSuperNodes = new Map();
+    let x = factory.X_OFFSET * 6; // position after core columns
+    snigels.forEach((snigel, idx) => {
+        const snigelOutputTemplate = node_defs_1.snigelControlDef.outputs[0];
+        const dynamicInputs = snigel.sources.map((_, i) => ({
+            label: `Source ${i + 1}`, type: 'source/device',
+        }));
+        dynamicInputs.push({ label: `Source ${dynamicInputs.length + 1}`, type: 'source/device' });
+        const snigelOutputsList = snigel.outputs?.length
+            ? snigel.outputs
+            : [{ id: `${snigel.id}-out1`, video: {}, type: 'pvw' }];
+        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: codecToEditorValue(snigel.video?.encoder?.codec),
+            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) => typeof s === 'object' && s.type === 'super')
+            .forEach(ss => {
+            const dynamicSSInputs = ss.sources.map((_, i) => ({
+                label: `Source ${i + 1}`, type: 'source/device',
+            }));
+            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;
+                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/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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';
+export declare const SnigelPlugin: ISesameEditorPlugin<Node, Edge>;
+export * from './types';

package/dist/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * 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);
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnigelPlugin = void 0;
+const node_defs_1 = require("./node-defs");
+const graph_builder_1 = require("./graph-builder");
+const config_serializer_1 = require("./config-serializer");
+exports.SnigelPlugin = {
+    id: 'com.stinkycomputing.snigel',
+    nodeTypes: [node_defs_1.snigelControlDef, node_defs_1.snigelOutputDef, node_defs_1.snigelSuperSourceDef],
+    buildNodes: graph_builder_1.buildSnigelNodes,
+    serializeNodes: config_serializer_1.serializeSnigelNodes,
+};
+__exportStar(require("./types"), exports);

package/dist/node-defs.d.ts

@@ -0,0 +1,8 @@
+/** Node type definitions for all three Snigel node types. */
+import type { NodeTypeDef, MetadataDef } from '@stinkycomputing/sesame-editor-api';
+export declare const snigelStateMetadata: MetadataDef;
+export declare const snigelCommandsMetadata: MetadataDef;
+export declare const snigelColor = "#784212";
+export declare const snigelControlDef: NodeTypeDef;
+export declare const snigelOutputDef: NodeTypeDef;
+export declare const snigelSuperSourceDef: NodeTypeDef;

package/dist/node-defs.js

@@ -0,0 +1,89 @@
+"use strict";
+/** Node type definitions for all three Snigel node types. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snigelSuperSourceDef = exports.snigelOutputDef = exports.snigelControlDef = exports.snigelColor = exports.snigelCommandsMetadata = exports.snigelStateMetadata = void 0;
+exports.snigelStateMetadata = {
+    id: 'snigel.jlc.state.v1',
+    label: 'Remote Control State',
+    direction: 'emit',
+    portType: 'metadata/snigel-state',
+    format: 'binary',
+};
+exports.snigelCommandsMetadata = {
+    id: 'snigel.jlc.commands.v1',
+    label: 'Remote Control Commands',
+    direction: 'receive',
+    portType: 'metadata/snigel-commands',
+    format: 'binary',
+};
+exports.snigelColor = '#784212';
+exports.snigelControlDef = {
+    type: 'snigel/control',
+    title: 'Snigel Replay',
+    category: 'snigel',
+    menuGroup: 'Snigel',
+    menuOrder: 7,
+    menuItemOrder: -1,
+    color: exports.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: ['avc', '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: [exports.snigelStateMetadata, exports.snigelCommandsMetadata],
+};
+exports.snigelOutputDef = {
+    type: 'snigel/output',
+    title: 'Snigel Output',
+    category: 'snigel-output',
+    menuGroup: 'Snigel',
+    menuOrder: 7,
+    color: exports.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' },
+};
+exports.snigelSuperSourceDef = {
+    type: 'snigel/super-source',
+    title: 'Snigel Super Slow',
+    category: 'snigel-super',
+    menuGroup: 'Snigel',
+    menuOrder: 7,
+    color: exports.snigelColor,
+    inputs: [
+        { label: 'Source 1', type: 'source/device' },
+    ],
+    outputs: [
+        { label: 'Source', type: 'source/device' },
+    ],
+    widgets: [],
+    defaultProperties: { id: '' },
+    dynamicPorts: true,
+};

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+/** Snigel-specific config types (formerly in sesame-interop). */
+export type SnigelCodec = 'avc' | 'hevc' | 'av1';
+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?: {
+            codec?: SnigelCodec;
+            bitrateKbs?: number;
+        };
+    };
+    controllerPort: string;
+    outputs?: ISnigelOutput[];
+}
+export type SnigelOutputType = 'pgm' | 'pvw';
+export interface ISnigelOutput {
+    id: string;
+    type: SnigelOutputType;
+    video: Record<string, unknown>;
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+/** Snigel-specific config types (formerly in sesame-interop). */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@stinkycomputing/sesame-snigel-plugin",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Snigel replay plugin for the Sesame config editor",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc"
   },

package/src/config-serializer.ts

@@ -1,103 +0,0 @@
-/**
- * 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

@@ -1,171 +0,0 @@
-/**
- * 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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,94 +0,0 @@
-/** 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

@@ -1,32 +0,0 @@
-/** 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>;
-}