@tuongaz/seeflow 0.1.26 → 0.1.28

package/src/proxy.ts

@@ -31,7 +31,7 @@ export interface PlayResult {
 
 export interface RunPlayOptions {
   events: EventBus;
-  demoId: string;
+  flowId: string;
   nodeId: string;
   /** Project root (`<repoPath>`). Script resolves under `<cwd>/.seeflow/`. */
   cwd: string;
@@ -103,24 +103,24 @@ async function writeStdinPayload(handle: SpawnHandle, input: unknown): Promise<v
   }
 }
 
-// Live play-script handles indexed by demoId. Populated by runPlay() on spawn;
+// Live play-script handles indexed by flowId. Populated by runPlay() on spawn;
 // entries are removed when each handle's `exited` promise resolves (success
-// AND error paths). `stopAllPlays(demoId)` consults this map to terminate
+// AND error paths). `stopAllPlays(flowId)` consults this map to terminate
 // every in-flight play for a demo on /reset.
 const livePlayHandles = new Map<string, Set<SpawnHandle>>();
 
-function registerLiveHandle(demoId: string, handle: SpawnHandle): void {
-  let set = livePlayHandles.get(demoId);
+function registerLiveHandle(flowId: string, handle: SpawnHandle): void {
+  let set = livePlayHandles.get(flowId);
   if (!set) {
     set = new Set();
-    livePlayHandles.set(demoId, set);
+    livePlayHandles.set(flowId, set);
   }
   set.add(handle);
   handle.exited.finally(() => {
-    const current = livePlayHandles.get(demoId);
+    const current = livePlayHandles.get(flowId);
     if (!current) return;
     current.delete(handle);
-    if (current.size === 0) livePlayHandles.delete(demoId);
+    if (current.size === 0) livePlayHandles.delete(flowId);
   });
 }
 
@@ -138,21 +138,21 @@ async function killWithGrace(handle: SpawnHandle): Promise<void> {
   }
 }
 
-// Kill every live play-script for `demoId` (SIGTERM → 2s grace → SIGKILL in
-// parallel) and wait for each to exit. Idempotent on an unknown demoId. The
-// map is keyed by demoId so a stop on demo A never touches demo B.
-export async function stopAllPlays(demoId: string): Promise<void> {
-  const set = livePlayHandles.get(demoId);
+// Kill every live play-script for `flowId` (SIGTERM → 2s grace → SIGKILL in
+// parallel) and wait for each to exit. Idempotent on an unknown flowId. The
+// map is keyed by flowId so a stop on demo A never touches demo B.
+export async function stopAllPlays(flowId: string): Promise<void> {
+  const set = livePlayHandles.get(flowId);
   if (!set || set.size === 0) return;
   const handles = [...set];
   // Clear eagerly so a parallel runPlay can't double-count an entry we're
   // about to await on. The exited.finally() will no-op the second delete.
-  livePlayHandles.delete(demoId);
+  livePlayHandles.delete(flowId);
   await Promise.all(handles.map((h) => killWithGrace(h)));
 }
 
 export async function runPlay(options: RunPlayOptions): Promise<PlayResult> {
-  const { events, demoId, nodeId, cwd, action } = options;
+  const { events, flowId, nodeId, cwd, action } = options;
   const spawner = options.spawner ?? defaultProcessSpawner;
   const runId = crypto.randomUUID();
 
@@ -160,7 +160,7 @@ export async function runPlay(options: RunPlayOptions): Promise<PlayResult> {
   if (!resolved.ok) {
     events.broadcast({
       type: 'node:error',
-      demoId,
+      flowId,
       payload: { nodeId, runId, message: SCRIPT_PATH_ESCAPE },
     });
     return { runId, error: SCRIPT_PATH_ESCAPE };
@@ -168,7 +168,7 @@ export async function runPlay(options: RunPlayOptions): Promise<PlayResult> {
 
   events.broadcast({
     type: 'node:running',
-    demoId,
+    flowId,
     payload: {
       nodeId,
       runId,
@@ -179,7 +179,7 @@ export async function runPlay(options: RunPlayOptions): Promise<PlayResult> {
 
   const wantsStdin = action.input !== undefined;
   const env = buildChildEnv({
-    SEEFLOW_DEMO_ID: demoId,
+    SEEFLOW_DEMO_ID: flowId,
     SEEFLOW_NODE_ID: nodeId,
     SEEFLOW_RUN_ID: runId,
   });
@@ -196,13 +196,13 @@ export async function runPlay(options: RunPlayOptions): Promise<PlayResult> {
     const message = err instanceof Error ? err.message : String(err);
     events.broadcast({
       type: 'node:error',
-      demoId,
+      flowId,
       payload: { nodeId, runId, message },
     });
     return { runId, error: message };
   }
 
-  registerLiveHandle(demoId, handle);
+  registerLiveHandle(flowId, handle);
 
   // Drain stdout AND stderr CONCURRENTLY with the process running so OS pipe
   // buffers (~64 KB) don't fill up and deadlock the child.
@@ -242,7 +242,7 @@ export async function runPlay(options: RunPlayOptions): Promise<PlayResult> {
     const message = `script timed out after ${timeoutMs}ms`;
     events.broadcast({
       type: 'node:error',
-      demoId,
+      flowId,
       payload: { nodeId, runId, message },
     });
     return { runId, error: message };
@@ -260,7 +260,7 @@ export async function runPlay(options: RunPlayOptions): Promise<PlayResult> {
     }
     events.broadcast({
       type: 'node:done',
-      demoId,
+      flowId,
       payload: { nodeId, runId, status: 200, body },
     });
     return { runId, status: 200, body };
@@ -271,7 +271,7 @@ export async function runPlay(options: RunPlayOptions): Promise<PlayResult> {
   const message = truncated.length > 0 ? truncated : `script exited with code ${code}`;
   events.broadcast({
     type: 'node:error',
-    demoId,
+    flowId,
     payload: { nodeId, runId, message },
   });
   return { runId, error: message };
@@ -279,7 +279,7 @@ export async function runPlay(options: RunPlayOptions): Promise<PlayResult> {
 
 export interface RunResetOptions {
   events: EventBus;
-  demoId: string;
+  flowId: string;
   /** Project root (`<repoPath>`). Script resolves under `<cwd>/.seeflow/`. */
   cwd: string;
   action: ResetAction;
@@ -300,21 +300,21 @@ export interface ResetResult {
 // returned shape. Callers (the /reset endpoint) decide what HTTP status to
 // surface; this returns `{ ok }` plus body/error so the endpoint can map.
 export async function runReset(options: RunResetOptions): Promise<ResetResult> {
-  const { events, demoId, cwd, action } = options;
+  const { events, flowId, cwd, action } = options;
   const spawner = options.spawner ?? defaultProcessSpawner;
 
   const resolved = resolveScript(cwd, action.scriptPath);
   if (!resolved.ok) {
     events.broadcast({
       type: 'demo:reset',
-      demoId,
+      flowId,
       payload: { ok: false, error: SCRIPT_PATH_ESCAPE },
     });
     return { ok: false, error: SCRIPT_PATH_ESCAPE };
   }
 
   const wantsStdin = action.input !== undefined;
-  const env = buildChildEnv({ SEEFLOW_DEMO_ID: demoId });
+  const env = buildChildEnv({ SEEFLOW_DEMO_ID: flowId });
 
   let handle: SpawnHandle;
   try {
@@ -328,7 +328,7 @@ export async function runReset(options: RunResetOptions): Promise<ResetResult> {
     const message = err instanceof Error ? err.message : String(err);
     events.broadcast({
       type: 'demo:reset',
-      demoId,
+      flowId,
       payload: { ok: false, error: message },
     });
     return { ok: false, error: message };
@@ -357,7 +357,7 @@ export async function runReset(options: RunResetOptions): Promise<ResetResult> {
     const message = `reset script timed out after ${timeoutMs}ms`;
     events.broadcast({
       type: 'demo:reset',
-      demoId,
+      flowId,
       payload: { ok: false, error: message },
     });
     return { ok: false, error: message };
@@ -375,7 +375,7 @@ export async function runReset(options: RunResetOptions): Promise<ResetResult> {
     }
     events.broadcast({
       type: 'demo:reset',
-      demoId,
+      flowId,
       payload: { ok: true, body },
     });
     return { ok: true, body };
@@ -386,7 +386,7 @@ export async function runReset(options: RunResetOptions): Promise<ResetResult> {
   const message = truncated.length > 0 ? truncated : `reset script exited with code ${code}`;
   events.broadcast({
     type: 'demo:reset',
-    demoId,
+    flowId,
     payload: { ok: false, error: message },
   });
   return { ok: false, error: message };

package/src/registry.ts

@@ -2,12 +2,12 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { seeflowHome } from './paths.ts';
 
-export interface DemoEntry {
+export interface FlowEntry {
   id: string;
   slug: string;
   name: string;
   repoPath: string;
-  demoPath: string;
+  architecturePath: string;
   lastModified: number;
   valid: boolean;
 }
@@ -15,18 +15,21 @@ export interface DemoEntry {
 export interface RegisterInput {
   name: string;
   repoPath: string;
-  demoPath: string;
+  architecturePath: string;
   valid?: boolean;
   lastModified?: number;
 }
 
 export interface Registry {
-  list(): DemoEntry[];
-  getById(id: string): DemoEntry | undefined;
-  getBySlug(slug: string): DemoEntry | undefined;
-  getByRepoPath(repoPath: string): DemoEntry | undefined;
-  getByRepoPathAndDemoPath(repoPath: string, demoPath: string): DemoEntry | undefined;
-  upsert(input: RegisterInput): DemoEntry;
+  list(): FlowEntry[];
+  getById(id: string): FlowEntry | undefined;
+  getBySlug(slug: string): FlowEntry | undefined;
+  getByRepoPath(repoPath: string): FlowEntry | undefined;
+  getByRepoPathAndArchitecturePath(
+    repoPath: string,
+    architecturePath: string,
+  ): FlowEntry | undefined;
+  upsert(input: RegisterInput): FlowEntry;
   remove(id: string): boolean;
 }
 
@@ -44,7 +47,7 @@ export function slugify(name: string): string {
 
 export function createRegistry(options: { path?: string } = {}): Registry {
   const path = options.path ?? defaultRegistryPath();
-  const entries = new Map<string, DemoEntry>();
+  const entries = new Map<string, FlowEntry>();
 
   if (existsSync(path)) {
     try {
@@ -57,7 +60,13 @@ export function createRegistry(options: { path?: string } = {}): Registry {
             typeof e.slug === 'string' &&
             typeof e.repoPath === 'string'
           ) {
-            entries.set(e.id, e as DemoEntry);
+            if (typeof e.architecturePath !== 'string') {
+              console.warn(
+                `[registry] ignoring legacy entry ${e.id} (${e.slug}) — pre-split format, please re-register`,
+              );
+              continue;
+            }
+            entries.set(e.id, e as FlowEntry);
           }
         }
       }
@@ -71,16 +80,19 @@ export function createRegistry(options: { path?: string } = {}): Registry {
     writeFileSync(path, JSON.stringify([...entries.values()], null, 2));
   };
 
-  const findByRepoPath = (repoPath: string): DemoEntry | undefined => {
+  const findByRepoPath = (repoPath: string): FlowEntry | undefined => {
     for (const e of entries.values()) {
       if (e.repoPath === repoPath) return e;
     }
     return undefined;
   };
 
-  const findByRepoPathAndDemoPath = (repoPath: string, demoPath: string): DemoEntry | undefined => {
+  const findByRepoPathAndArchitecturePath = (
+    repoPath: string,
+    architecturePath: string,
+  ): FlowEntry | undefined => {
     for (const e of entries.values()) {
-      if (e.repoPath === repoPath && e.demoPath === demoPath) return e;
+      if (e.repoPath === repoPath && e.architecturePath === architecturePath) return e;
     }
     return undefined;
   };
@@ -98,16 +110,16 @@ export function createRegistry(options: { path?: string } = {}): Registry {
     getById: (id) => entries.get(id),
     getBySlug: (slug) => [...entries.values()].find((e) => e.slug === slug),
     getByRepoPath: findByRepoPath,
-    getByRepoPathAndDemoPath: findByRepoPathAndDemoPath,
+    getByRepoPathAndArchitecturePath: findByRepoPathAndArchitecturePath,
     upsert(input) {
       const lastModified = input.lastModified ?? Date.now();
       const valid = input.valid ?? true;
-      const existing = findByRepoPathAndDemoPath(input.repoPath, input.demoPath);
+      const existing = findByRepoPathAndArchitecturePath(input.repoPath, input.architecturePath);
       if (existing) {
-        const updated: DemoEntry = {
+        const updated: FlowEntry = {
           ...existing,
           name: input.name,
-          demoPath: input.demoPath,
+          architecturePath: input.architecturePath,
           lastModified,
           valid,
         };
@@ -117,12 +129,12 @@ export function createRegistry(options: { path?: string } = {}): Registry {
       }
       const id = crypto.randomUUID();
       const slug = uniqueSlug(slugify(input.name));
-      const entry: DemoEntry = {
+      const entry: FlowEntry = {
         id,
         slug,
         name: input.name,
         repoPath: input.repoPath,
-        demoPath: input.demoPath,
+        architecturePath: input.architecturePath,
         lastModified,
         valid,
       };

package/src/schema.ts

@@ -396,21 +396,21 @@ const ConnectorSchema = z.discriminatedUnion('kind', [
   DefaultConnectorSchema,
 ]);
 
-export const DemoSchema = z
+export const FlowSchema = z
   .object({
-    version: z.literal(1),
+    version: z.literal(2),
     name: z.string().min(1),
     nodes: z.array(NodeSchema),
     connectors: z.array(ConnectorSchema),
     // Optional one-shot script the studio runs when the user clicks Restart.
     // Lets the running app wipe its own in-memory state. The studio kills
-    // every live play + status script for the demo BEFORE invoking this
+    // every live play + status script for the flow BEFORE invoking this
     // script (US-008), so the script sees no stragglers.
     resetAction: ResetActionSchema.optional(),
   })
-  .superRefine((demo, ctx) => {
-    const nodeIds = new Set(demo.nodes.map((n) => n.id));
-    demo.connectors.forEach((c, idx) => {
+  .superRefine((flow, ctx) => {
+    const nodeIds = new Set(flow.nodes.map((n) => n.id));
+    flow.connectors.forEach((c, idx) => {
       if (!nodeIds.has(c.source)) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
@@ -428,8 +428,8 @@ export const DemoSchema = z
     });
   });
 
-export type Demo = z.infer<typeof DemoSchema>;
-export type DemoNode = z.infer<typeof NodeSchema>;
+export type Flow = z.infer<typeof FlowSchema>;
+export type FlowNode = z.infer<typeof NodeSchema>;
 export type ShapeNode = z.infer<typeof ShapeNodeSchema>;
 export type ImageNode = z.infer<typeof ImageNodeSchema>;
 export type IconNode = z.infer<typeof IconNodeSchema>;
@@ -452,3 +452,247 @@ export type StatusAction = z.infer<typeof StatusActionSchema>;
 export type StatusReport = z.infer<typeof StatusReportSchema>;
 export type ResetAction = z.infer<typeof ResetActionSchema>;
 export type StateSource = z.infer<typeof StateSourceSchema>;
+
+// =============================================================================
+// Architecture schema — pure semantic data, every visual/layout field stripped.
+// What lives on disk in <project>/.seeflow/architecture.json after the split.
+// =============================================================================
+
+const ArchitectureNodeDataBaseShape = {
+  name: z.string().min(1),
+  kind: z.string().min(1),
+  stateSource: StateSourceSchema,
+  handlerModule: z.string().optional(),
+  icon: z.string().optional(),
+  ...NodeDescriptionBaseShape,
+};
+
+const ArchitecturePlayNodeDataSchema = z
+  .object({
+    ...ArchitectureNodeDataBaseShape,
+    playAction: PlayActionSchema,
+    statusAction: StatusActionSchema.optional(),
+  })
+  .strict();
+
+const ArchitectureStateNodeDataSchema = z
+  .object({
+    ...ArchitectureNodeDataBaseShape,
+    playAction: PlayActionSchema.optional(),
+    statusAction: StatusActionSchema.optional(),
+  })
+  .strict();
+
+const ArchitectureShapeNodeDataSchema = z
+  .object({
+    shape: ShapeKindSchema,
+    name: z.string().optional(),
+    ...NodeDescriptionBaseShape,
+  })
+  .strict();
+
+const ArchitectureImageNodeDataSchema = z
+  .object({
+    path: z.string().min(1).refine(isCleanRelativePath, {
+      message: 'path must be a relative path under .seeflow/ (no absolute / traversal)',
+    }),
+    alt: z.string().optional(),
+    ...NodeDescriptionBaseShape,
+  })
+  .strict();
+
+const ArchitectureIconNodeDataSchema = z
+  .object({
+    icon: z.string().min(1),
+    alt: z.string().optional(),
+    name: z.string().optional(),
+    ...NodeDescriptionBaseShape,
+  })
+  .strict();
+
+const ArchitectureHtmlNodeDataSchema = z
+  .object({
+    htmlPath: z.string().min(1).refine(isCleanRelativePath, {
+      message: 'htmlPath must be a relative path under .seeflow/ (no absolute / traversal)',
+    }),
+    name: z.string().optional(),
+    icon: z.string().optional(),
+    ...NodeDescriptionBaseShape,
+  })
+  .strict();
+
+const ArchitectureNodeBaseShape = {
+  id: z.string().min(1),
+};
+
+const ArchitectureNodeSchema = z.discriminatedUnion('type', [
+  z
+    .object({
+      ...ArchitectureNodeBaseShape,
+      type: z.literal('playNode'),
+      data: ArchitecturePlayNodeDataSchema,
+    })
+    .strict(),
+  z
+    .object({
+      ...ArchitectureNodeBaseShape,
+      type: z.literal('stateNode'),
+      data: ArchitectureStateNodeDataSchema,
+    })
+    .strict(),
+  z
+    .object({
+      ...ArchitectureNodeBaseShape,
+      type: z.literal('shapeNode'),
+      data: ArchitectureShapeNodeDataSchema,
+    })
+    .strict(),
+  z
+    .object({
+      ...ArchitectureNodeBaseShape,
+      type: z.literal('imageNode'),
+      data: ArchitectureImageNodeDataSchema,
+    })
+    .strict(),
+  z
+    .object({
+      ...ArchitectureNodeBaseShape,
+      type: z.literal('iconNode'),
+      data: ArchitectureIconNodeDataSchema,
+    })
+    .strict(),
+  z
+    .object({
+      ...ArchitectureNodeBaseShape,
+      type: z.literal('htmlNode'),
+      data: ArchitectureHtmlNodeDataSchema,
+    })
+    .strict(),
+]);
+
+const ArchitectureConnectorBaseShape = {
+  id: z.string().min(1),
+  source: z.string().min(1),
+  target: z.string().min(1),
+  label: z.string().optional(),
+};
+
+const ArchitectureConnectorSchema = z.discriminatedUnion('kind', [
+  z
+    .object({
+      ...ArchitectureConnectorBaseShape,
+      kind: z.literal('http'),
+      method: HttpMethodSchema.optional(),
+      url: z.string().min(1).optional(),
+    })
+    .strict(),
+  z
+    .object({
+      ...ArchitectureConnectorBaseShape,
+      kind: z.literal('event'),
+      eventName: z.string().min(1),
+    })
+    .strict(),
+  z
+    .object({
+      ...ArchitectureConnectorBaseShape,
+      kind: z.literal('queue'),
+      queueName: z.string().min(1),
+    })
+    .strict(),
+  z
+    .object({
+      ...ArchitectureConnectorBaseShape,
+      kind: z.literal('default'),
+    })
+    .strict(),
+]);
+
+export const ArchitectureSchema = z
+  .object({
+    version: z.literal(2),
+    name: z.string().min(1),
+    resetAction: ResetActionSchema.optional(),
+    nodes: z.array(ArchitectureNodeSchema),
+    connectors: z.array(ArchitectureConnectorSchema),
+  })
+  .strict()
+  .superRefine((arch, ctx) => {
+    const ids = new Set(arch.nodes.map((n) => n.id));
+    arch.connectors.forEach((c, idx) => {
+      if (!ids.has(c.source)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ['connectors', idx, 'source'],
+          message: `Connector ${c.id} references unknown source node: ${c.source}`,
+        });
+      }
+      if (!ids.has(c.target)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ['connectors', idx, 'target'],
+          message: `Connector ${c.id} references unknown target node: ${c.target}`,
+        });
+      }
+    });
+  });
+
+export type Architecture = z.infer<typeof ArchitectureSchema>;
+export type ArchitectureNode = z.infer<typeof ArchitectureNodeSchema>;
+export type ArchitectureConnector = z.infer<typeof ArchitectureConnectorSchema>;
+
+// =============================================================================
+// Style schema — keyed map of presentation overrides, side-table by id.
+// What lives on disk in <project>/.seeflow/style.json (optional file).
+// =============================================================================
+
+const NodeStyleSchema = z
+  .object({
+    position: PositionSchema.optional(),
+    width: z.number().positive().optional(),
+    height: z.number().positive().optional(),
+    borderColor: ColorTokenSchema.optional(),
+    backgroundColor: ColorTokenSchema.optional(),
+    borderSize: z.number().positive().optional(),
+    borderStyle: z.enum(['solid', 'dashed', 'dotted']).optional(),
+    fontSize: z.number().positive().optional(),
+    textColor: ColorTokenSchema.optional(),
+    cornerRadius: z.number().min(0).optional(),
+    locked: z.boolean().optional(),
+    // imageNode-specific
+    borderWidth: z.number().min(1).max(8).optional(),
+    // iconNode-specific
+    color: ColorTokenSchema.optional(),
+    strokeWidth: z.number().min(0.5).max(4).optional(),
+    // htmlNode-specific
+    autoSize: z.boolean().optional(),
+  })
+  .strict();
+
+const ConnectorStyleEntrySchema = z
+  .object({
+    sourceHandle: SourceHandleIdSchema.optional(),
+    targetHandle: TargetHandleIdSchema.optional(),
+    sourceHandleAutoPicked: z.boolean().optional(),
+    targetHandleAutoPicked: z.boolean().optional(),
+    sourcePin: EdgePinSchema.optional(),
+    targetPin: EdgePinSchema.optional(),
+    style: ConnectorStyleSchema.optional(),
+    color: ColorTokenSchema.optional(),
+    direction: ConnectorDirectionSchema.optional(),
+    borderSize: z.number().positive().optional(),
+    path: ConnectorPathSchema.optional(),
+    fontSize: z.number().positive().optional(),
+  })
+  .strict();
+
+export const StyleSchema = z
+  .object({
+    nodes: z.record(z.string(), NodeStyleSchema).optional(),
+    connectors: z.record(z.string(), ConnectorStyleEntrySchema).optional(),
+  })
+  .strict();
+
+export type Style = z.infer<typeof StyleSchema>;
+export type NodeStyle = z.infer<typeof NodeStyleSchema>;
+export type ConnectorStyleEntry = z.infer<typeof ConnectorStyleEntrySchema>;

package/src/sdk-template.ts

@@ -20,7 +20,7 @@ const readEnv = (key: string): string | undefined => {
 };
 
 export async function emit(
-  demoId: string,
+  flowId: string,
   nodeId: string,
   status: EmitStatus,
   opts: EmitOptions = {},
@@ -31,7 +31,7 @@ export async function emit(
   await fetch(\`\${base}/api/emit\`, {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ demoId, nodeId, status, runId: opts.runId, payload: opts.payload }),
+    body: JSON.stringify({ flowId, nodeId, status, runId: opts.runId, payload: opts.payload }),
   });
 }
 `;

package/src/sdk-writer.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import type { Demo } from './schema.ts';
+import type { Flow } from './schema.ts';
 import { EMIT_TEMPLATE } from './sdk-template.ts';
 
 export type SdkWriteOutcome = 'skipped' | 'written' | 'present';
@@ -16,7 +16,7 @@ export interface SdkWriteResult {
  * node with `stateSource.kind === 'event'`. Idempotent: existing files are
  * never overwritten. The only place M1's CLI mutates a user repo.
  */
-export function writeSdkEmitIfNeeded(repoPath: string, demo: Demo): SdkWriteResult {
+export function writeSdkEmitIfNeeded(repoPath: string, demo: Flow): SdkWriteResult {
   const hasEventState = demo.nodes.some(
     (n) =>
       n.type !== 'shapeNode' &&