@oomol-lab/open-flow 0.1.0-beta.73 → 0.1.0-beta.75

package/src/control/common/eventSourceSchemas.ts

@@ -0,0 +1,13 @@
+import type { CreateEventSource, UpdateEventSource } from './eventSources.ts'
+
+import { z } from 'zod'
+import catalog from '../../trigger/providers/catalog.generated.json' with { type: 'json' }
+
+function requestSchema(schema: unknown): z.ZodObject {
+  return (z.fromJSONSchema(schema as Parameters<typeof z.fromJSONSchema>[0]) as z.ZodObject).extend({ name: z.string().trim().min(1).max(128) })
+}
+
+const sources = catalog.flatMap((entry) => ('source' in entry && entry.source != null ? [entry.source] : []))
+export const createEventSourceSchema = z.union(sources.map((source) => requestSchema(source.createSchema))) as unknown as z.ZodType<CreateEventSource>
+export const updateEventSourceSchema = requestSchema(sources[0]!.updateSchema) as unknown as z.ZodType<UpdateEventSource>
+export const eventSourceRevisionSchema = z.strictObject({ version: z.literal(1), expectedRevision: z.int().positive() })

package/src/control/common/eventSources.ts

@@ -0,0 +1,186 @@
+import { z } from 'zod'
+
+const id = z.string().min(1).max(256)
+const eventType = z.string().regex(/^[a-z][a-z0-9_.:]{0,127}$/)
+const name = z.string().trim().min(1).max(128)
+
+const eventSourceSchema = z.object({
+  version: z.literal(1),
+  sourceId: id,
+  revision: z.int().positive(),
+  name,
+  provider: z.enum(['feishu', 'feishu_app_bot', 'slackbot', 'intercom', 'sentry', 'zoom', 'fireflies', 'jira']),
+  appId: id.nullable(),
+  workspaceId: id.optional(),
+  installationId: id.optional(),
+  organizationId: id.optional(),
+  projectId: id.optional(),
+  projectKey: id.optional(),
+  subscriptionStatus: z.enum(['idle', 'pending', 'ready', 'error']).optional(),
+  lastError: z.string().optional(),
+  signingSecretConfigured: z.boolean().optional(),
+  connectionId: id,
+  teamId: id.nullable(),
+  enabled: z.boolean(),
+  eventTypes: z.array(eventType),
+  manageSubscriptions: z.boolean().nullable(),
+  verificationTokenConfigured: z.boolean().nullable(),
+  encryptKeyConfigured: z.boolean().nullable(),
+  endpointUrl: z.string().nullable(),
+  verifiedAt: z.string().nullable(),
+  lastReceivedAt: z.string().nullable(),
+  updatedAt: z.string(),
+  consumers: z.array(z.object({ flowId: id, flowName: z.string(), triggerNodeId: id })),
+})
+
+export const eventSourceViewSchema = eventSourceSchema.pick({
+  appId: true,
+  workspaceId: true,
+  installationId: true,
+  organizationId: true,
+  projectId: true,
+  projectKey: true,
+  subscriptionStatus: true,
+  lastError: true,
+  signingSecretConfigured: true,
+  manageSubscriptions: true,
+  verificationTokenConfigured: true,
+  encryptKeyConfigured: true,
+  verifiedAt: true,
+})
+
+export interface CreateFeishuEventSource {
+  readonly kind?: 'feishu'
+  readonly version: 1
+  readonly name: string
+  readonly connectionId: string
+  readonly teamId: string | null
+  readonly verificationToken: string
+  readonly encryptKey: string
+  readonly eventTypes: string[]
+  readonly manageSubscriptions: boolean
+}
+
+export interface CreateSlackEventSource {
+  readonly kind: 'slack'
+  readonly version: 1
+  readonly name: string
+  readonly connectionId: string
+  readonly teamId: string | null
+  readonly appId: string
+  readonly workspaceId: string
+  readonly signingSecret: string
+  readonly eventTypes: string[]
+}
+
+export interface CreateIntercomEventSource {
+  readonly kind: 'intercom'
+  readonly version: 1
+  readonly name: string
+  readonly connectionId: string
+  readonly teamId: string | null
+  readonly appId: string
+  readonly signingSecret: string
+  readonly eventTypes: string[]
+}
+
+export interface CreateSentryEventSource {
+  readonly kind: 'sentry'
+  readonly version: 1
+  readonly name: string
+  readonly connectionId: string
+  readonly teamId: string | null
+  readonly appId: string
+  readonly installationId: string
+  readonly organizationId: string
+  readonly signingSecret: string
+  readonly eventTypes: string[]
+}
+
+export interface CreateZoomEventSource {
+  readonly kind: 'zoom'
+  readonly version: 1
+  readonly name: string
+  readonly connectionId: string
+  readonly teamId: string | null
+  readonly appId: string
+  readonly signingSecret: string
+  readonly eventTypes: string[]
+}
+
+export interface CreateFirefliesEventSource {
+  readonly kind: 'fireflies'
+  readonly version: 1
+  readonly name: string
+  readonly connectionId: string
+  readonly teamId: string | null
+  readonly signingSecret: string
+  readonly eventTypes: string[]
+}
+
+export interface CreateJiraEventSource {
+  readonly kind: 'jira'
+  readonly version: 1
+  readonly name: string
+  readonly connectionId: string
+  readonly teamId: string | null
+  readonly project: string
+  readonly eventTypes: string[]
+}
+
+export type CreateEventSource =
+  | CreateFeishuEventSource
+  | CreateSlackEventSource
+  | CreateIntercomEventSource
+  | CreateSentryEventSource
+  | CreateZoomEventSource
+  | CreateFirefliesEventSource
+  | CreateJiraEventSource
+
+export interface UpdateEventSource {
+  readonly signingSecret?: string
+  readonly version: 1
+  readonly expectedRevision: number
+  readonly name: string
+  readonly enabled: boolean
+  readonly eventTypes: string[]
+  readonly verificationToken?: string
+  readonly encryptKey?: string
+}
+
+export interface EventSource {
+  readonly version: 1
+  readonly sourceId: string
+  readonly revision: number
+  readonly name: string
+  readonly provider: 'feishu' | 'feishu_app_bot' | 'slackbot' | 'intercom' | 'sentry' | 'zoom' | 'fireflies' | 'jira'
+  readonly appId: string | null
+  readonly workspaceId?: string
+  readonly installationId?: string
+  readonly organizationId?: string
+  readonly projectId?: string
+  readonly projectKey?: string
+  readonly subscriptionStatus?: 'idle' | 'pending' | 'ready' | 'error'
+  readonly lastError?: string
+  readonly signingSecretConfigured?: boolean
+  readonly connectionId: string
+  readonly teamId: string | null
+  readonly enabled: boolean
+  readonly eventTypes: string[]
+  readonly manageSubscriptions: boolean | null
+  readonly verificationTokenConfigured: boolean | null
+  readonly encryptKeyConfigured: boolean | null
+  readonly endpointUrl: string | null
+  readonly verifiedAt: string | null
+  readonly lastReceivedAt: string | null
+  readonly updatedAt: string
+  readonly consumers: { flowId: string; flowName: string; triggerNodeId: string }[]
+}
+
+export function decodeEventSource(value: unknown): EventSource {
+  return eventSourceSchema.parse(value)
+}
+
+export function decodeEventSources(value: unknown): { readonly version: 1; readonly sources: readonly EventSource[]; readonly teamId?: string | null } {
+  return z.object({ version: z.literal(1), sources: z.array(eventSourceSchema), teamId: id.nullable().optional() }).parse(value)
+}

package/src/control/common/flowDecoders.ts

@@ -0,0 +1,153 @@
+import type { ErrorListener, Flow, FlowListItem, FlowPage, FlowResources, Variable, VariableListItem, VariableReferences } from './api.ts'
+
+import { requiredFields, integer, invalidResponse, record, string } from './decoding.ts'
+
+function strings(value: unknown): readonly string[] {
+  return Array.isArray(value) ? value.map(string) : invalidResponse()
+}
+
+function resourceReferences(input: unknown): FlowResources {
+  const source = record(input)
+  const draft = source.draft === null ? null : record(source.draft)
+  const shared = record(source.sharedAccess)
+  if (draft != null && !Array.isArray(draft.connections)) return invalidResponse()
+  if (!Array.isArray(shared.bindings)) return invalidResponse()
+  const accessRevision = integer(shared.accessRevision)
+  if (accessRevision < 0) return invalidResponse()
+  return {
+    draft:
+      draft == null
+        ? null
+        : {
+            ...(draft.calledFlowIds === undefined ? {} : { calledFlowIds: strings(draft.calledFlowIds) }),
+            variableNames: strings(draft.variableNames),
+            errorSourceFlowIds: strings(draft.errorSourceFlowIds),
+            connections: (draft.connections as unknown[]).map((value) => {
+              const connection = record(value)
+              return { providerId: string(connection.providerId), connectionId: string(connection.connectionId) }
+            }),
+          },
+    sharedAccess: {
+      accessRevision,
+      providerIds: strings(shared.providerIds),
+      bindings: shared.bindings.map((value) => {
+        const binding = record(value)
+        return {
+          providerId: string(binding.providerId),
+          connectionId: binding.connectionId === null ? null : string(binding.connectionId),
+          accessBindingId: string(binding.accessBindingId),
+        }
+      }),
+    },
+  }
+}
+
+export function flow(value: unknown): Flow {
+  const source = record(value)
+  const status = source.status
+  if (source.version != 1) return invalidResponse()
+  if (status != 'active' && status != 'retiring') return invalidResponse()
+  const target = source.live == null ? undefined : record(source.live)
+  if (target != null && (typeof target.enabled != 'boolean' || typeof target.hasStart != 'boolean')) return invalidResponse()
+  return {
+    ...(target == null
+      ? {}
+      : {
+          live: {
+            enabled: target.enabled as boolean,
+            hasStart: target.hasStart as boolean,
+            publicationId: string(target.publicationId),
+            revisionId: string(target.revisionId),
+          },
+        }),
+    createdAt: string(source.createdAt),
+    ...(source.connectorTeamId == null ? {} : { connectorTeamId: string(source.connectorTeamId) }),
+    draftRevisionId: string(source.draftRevisionId),
+    resourceReferences: resourceReferences(source.resourceReferences),
+    flowId: string(source.flowId),
+    name: string(source.name),
+    status: status as Flow['status'],
+    updatedAt: string(source.updatedAt),
+    version: 1,
+  }
+}
+
+export function flowListItem(value: unknown): FlowListItem {
+  const source = record(value)
+  const referenceCount = integer(source.referenceCount)
+  if (referenceCount < 0) return invalidResponse()
+  return { ...flow(source), referenceCount }
+}
+
+export function flowPage(value: unknown): FlowPage {
+  const source = record(value)
+  if (source.version != 1 || !Array.isArray(source.flows)) return invalidResponse()
+  const nextCursor = source.nextCursor
+  const total = source.total
+  if (nextCursor != null && typeof nextCursor != 'string') return invalidResponse()
+  if (total != null && !Number.isSafeInteger(total)) return invalidResponse()
+  return {
+    ...(nextCursor == null ? {} : { nextCursor }),
+    flows: source.flows.map(flowListItem),
+    ...(total == null ? {} : { total: total as number }),
+    version: 1,
+  }
+}
+
+export function variable(value: unknown): Variable {
+  const source = record(value)
+  requiredFields(source, ['name', 'updatedAt', 'value', 'version'])
+  if (source.version != 1 || typeof source.value != 'string') return invalidResponse()
+  const updatedAt = string(source.updatedAt)
+  try {
+    if (new Date(updatedAt).toISOString() != updatedAt) return invalidResponse()
+  } catch {
+    return invalidResponse()
+  }
+  return { name: string(source.name), updatedAt, value: source.value, version: 1 }
+}
+
+export function variableListItem(value: unknown): VariableListItem {
+  const source = record(value)
+  const { referenceCount, ...fields } = source
+  const count = integer(referenceCount)
+  if (count < 0) return invalidResponse()
+  return { ...variable(fields), referenceCount: count }
+}
+
+export function errorListener(value: unknown): ErrorListener {
+  const source = record(value)
+  if (typeof source.enabled != 'boolean') return invalidResponse()
+  return {
+    flowId: string(source.flowId),
+    flowName: string(source.flowName),
+    nodeId: string(source.nodeId),
+    nodeName: string(source.nodeName),
+    enabled: source.enabled,
+  }
+}
+
+export function variableReferences(input: unknown): VariableReferences {
+  const source = record(input)
+  requiredFields(source, ['version', 'references'])
+  if (source.version != 1 || !Array.isArray(source.references)) return invalidResponse()
+  return {
+    version: 1,
+    references: source.references.map((value) => {
+      const item = record(value)
+      requiredFields(item, ['flowId', 'flowName', 'draft', 'live'])
+      if (typeof item.draft != 'boolean') return invalidResponse()
+      const live = item.live === null ? null : record(item.live)
+      if (live != null) {
+        requiredFields(live, ['publicationId', 'enabled'])
+        if (typeof live.enabled != 'boolean') return invalidResponse()
+      }
+      return {
+        flowId: string(item.flowId),
+        flowName: string(item.flowName),
+        draft: item.draft,
+        live: live == null ? null : { publicationId: string(live.publicationId), enabled: live.enabled as boolean },
+      }
+    }),
+  }
+}

package/src/control/common/flowInspection.ts

@@ -0,0 +1,181 @@
+import type { ManagedTaskDefinition } from '../../flow/common/change.ts'
+import type { ConditionOperand, Graph, GraphNode, Group, InputPort, RevisionContent } from '../../flow/common/change.ts'
+import type { ConnectorAction, Draft, Flow, Live } from './api.ts'
+
+import { nodeInputPorts, nodeOutputPorts } from '../../flow/common/graph.ts'
+
+export async function inspectFlowDraft(flow: Flow, readDraft: () => Draft | Promise<Draft>) {
+  try {
+    return { flow, draft: await readDraft(), version: 1 as const }
+  } catch (error) {
+    if (!(error instanceof Error) || !('code' in error) || (error.code != 'flow.invalid' && error.code != 'flow.revision-upgrade-required')) throw error
+    return {
+      flow,
+      draft: null,
+      draftIssue: { code: error.code, message: error.message, revisionId: flow.draftRevisionId },
+      version: 1 as const,
+    }
+  }
+}
+
+export function flowInspection(inspected: Awaited<ReturnType<typeof inspectFlowDraft>>, live: Live | undefined, full = false) {
+  if (inspected.draft == null) return inspected
+  if (full) return { ...inspected, live }
+  const { flow, draft } = inspected
+  const { document, modules } = draft.content
+  return {
+    flow: { flowId: flow.flowId, name: flow.name, status: flow.status },
+    draft: {
+      revisionId: draft.revisionId,
+      graph: inspectGraph(document.graph),
+      bindings: document.bindings,
+      modules: Object.fromEntries(Object.entries(modules).map(([id, module]) => [id, { name: module.name, imports: module.imports }])),
+    },
+    ...(live == null
+      ? {}
+      : {
+          live: {
+            status: live.status,
+            hasUnpublishedChanges: live.hasUnpublishedChanges,
+            publication:
+              live.publication == null
+                ? null
+                : {
+                    publicationId: live.publication.publicationId,
+                    revisionId: live.publication.revisionId,
+                  },
+          },
+        }),
+    version: 1 as const,
+  }
+}
+
+function inspectPorts(ports: readonly (InputPort | Group)[]) {
+  return ports.flatMap((port) => ('handle' in port ? [{ handle: port.handle, ...(Object.hasOwn(port, 'value') ? { value: port.value } : {}) }] : []))
+}
+
+function inspectGraph(graph: Graph) {
+  return {
+    nodes: Object.fromEntries(Object.entries(graph.nodes).map(([id, node]) => [id, inspectNode(node)])),
+    edges: graph.edges,
+  }
+}
+
+function inspectNode(node: GraphNode): Record<string, unknown> {
+  const inputs = nodeInputPorts(node)
+  const defaults = Object.fromEntries(
+    Object.entries(inputs).flatMap(([handle, port]) =>
+      Object.hasOwn(port, 'value') && !('inputs' in node && Object.hasOwn(node.inputs, handle)) ? [[handle, port.value]] : [],
+    ),
+  )
+  const ports = {
+    inputHandles: Object.keys(inputs),
+    outputHandles: Object.keys(nodeOutputPorts(node)),
+    ...(Object.keys(defaults).length == 0 ? {} : { inputDefaults: defaults }),
+  }
+  switch (node.kind) {
+    case 'webhook-response':
+      return { ...node, ...ports }
+    case 'outputs':
+      return { ...node, ...ports, inputs: node.outputMappings }
+    case 'task': {
+      const { task, additionalInputs: _additional, ...instance } = node
+      return {
+        ...instance,
+        ...ports,
+        ...(task == null ? {} : 'executor' in task ? { executor: task.executor } : { moduleId: task.moduleId, capabilities: task.capabilities }),
+      }
+    }
+    case 'poll':
+    case 'integration': {
+      const { definition, ...instance } = node
+      return {
+        ...instance,
+        ...ports,
+        definition: {
+          key: definition.key,
+          provider: definition.provider,
+          definitionVersion: definition.definitionVersion,
+          configInputs: inspectPorts(definition.configInputs),
+          ...(definition.type == 'integration' ? { endpoint: definition.endpoint } : {}),
+        },
+      }
+    }
+    case 'webhook': {
+      const { bodyFields, ...instance } = node
+      return { ...instance, ...ports, bodyFields: inspectPorts(bodyFields) }
+    }
+    case 'wait':
+    case 'approval': {
+      const { inputDefinitions: _definitions, ...instance } = node
+      return { ...instance, ...ports }
+    }
+    case 'value':
+      return { ...node, ...ports, values: inspectPorts(node.values) }
+    case 'condition':
+      return {
+        ...node,
+        ...ports,
+        cases: node.cases.map((branch) => ({
+          ...branch,
+          groups: branch.groups.map((group) => ({
+            expressions: group.expressions.map((expression) => ({
+              ...expression,
+              left: inspectOperand(expression.left),
+              ...(expression.right == null ? {} : { right: inspectOperand(expression.right) }),
+            })),
+          })),
+        })),
+      }
+    case 'error':
+    case 'manual':
+    case 'start':
+    case 'cron':
+      return { ...node, ...ports }
+  }
+}
+
+function inspectOperand(operand: ConditionOperand) {
+  if (operand.kind == 'source') return operand
+  const { jsonSchema: _, ...value } = operand
+  return value
+}
+
+export function actionSummary(action: ConnectorAction) {
+  return {
+    actionId: action.actionId,
+    authenticated: action.authenticated,
+    ...(action.defaultConnection == null
+      ? {}
+      : {
+          defaultConnection: {
+            connectionId: action.defaultConnection.connectionId,
+            displayName: action.defaultConnection.displayName,
+            status: action.defaultConnection.status,
+          },
+        }),
+    description: action.description,
+    name: action.name,
+    serviceId: action.serviceId,
+    serviceName: action.serviceName,
+  }
+}
+
+export function nodeDetails(
+  content: RevisionContent,
+  nodeId: string,
+  node: GraphNode,
+): {
+  node: GraphNode
+  nodeId: string
+  module?: RevisionContent['modules'][string]
+  task?: ManagedTaskDefinition
+} {
+  if (node.kind != 'task') return { node, nodeId }
+  if ('moduleId' in node.task) {
+    const module = content.modules[node.task.moduleId]
+    return { node, nodeId, ...(module == null ? {} : { module }) }
+  }
+  const task = node.task
+  return { node, nodeId, ...(task == null ? {} : { task }) }
+}

package/src/control/common/flowNotifications.ts

@@ -0,0 +1,37 @@
+import type { CanvasCommand } from '../../canvas/common/commands.ts'
+
+export type FlowCatalogEvent =
+  | { readonly kind: 'flows.changed'; readonly version: 1 }
+  | { readonly kind: 'flow.created'; readonly flowId: string; readonly version: 1 }
+
+export type FlowChangeEvent =
+  | {
+      readonly kind: 'canvas.command'
+      readonly flowId: string
+      readonly command: CanvasCommand
+      readonly version: 1
+    }
+  | {
+      readonly accessRevision: number
+      readonly flowId: string
+      readonly kind: 'access.changed'
+      readonly version: 1
+    }
+  | {
+      readonly kind: 'draft.changed'
+      readonly flowId: string
+      readonly revisionId: string
+      readonly version: 1
+    }
+  | {
+      readonly flowId: string
+      readonly kind: 'run.created'
+      readonly runId: string
+      readonly version: 1
+    }
+  | {
+      readonly flowId: string
+      readonly kind: 'run.changed'
+      readonly runId: string
+      readonly version: 1
+    }

package/src/control/common/liveDetails.ts

@@ -0,0 +1,124 @@
+import type { RevisionContent } from '../../flow/common/change.ts'
+import type { Publication, TriggerBinding } from './api.ts'
+
+import { z } from 'zod'
+import { webhookSupportsBody } from '../../flow/common/webhookMethod.ts'
+import { flowInputFieldsView, authoringConfigurations } from './authoringSchema.ts'
+import { triggerConfiguration } from './authoringTriggers.ts'
+import { invalidResponse, record, string } from './decoding.ts'
+import { publication } from './publicationDecoders.ts'
+import { triggerBinding } from './triggerDecoders.ts'
+
+const metadata = { nodeId: z.string().min(1), name: z.string(), description: z.string().optional() }
+const binding = z.unknown().transform(triggerBinding)
+const provider = {
+  provider: z.string().min(1),
+  inputs: z.record(z.string(), z.discriminatedUnion('kind', [z.object({ kind: z.literal('value'), value: z.json() }), z.object({ kind: z.literal('unset') })])),
+}
+const entrySchema = z.discriminatedUnion('type', [
+  z.object({ ...metadata, type: z.literal('start'), config: authoringConfigurations.start }),
+  z.object({ ...metadata, type: z.literal('manual'), config: z.object({}) }),
+  z.object({ ...metadata, type: z.literal('webhook'), config: authoringConfigurations.webhook, binding }),
+  z.object({ ...metadata, type: z.literal('cron'), config: authoringConfigurations.cron, binding }),
+  z.object({ ...metadata, type: z.literal('error'), config: authoringConfigurations.error, binding }),
+  z.object({ ...metadata, ...provider, type: z.literal('poll'), config: authoringConfigurations.poll, binding }),
+  z.object({ ...metadata, ...provider, type: z.literal('integration'), config: authoringConfigurations.integration, binding }),
+])
+
+export type LiveEntry = z.infer<typeof entrySchema>
+export type LiveDetails = { readonly flowId: string; readonly version: 1 } & (
+  | { readonly inputDefs: null; readonly publication: null; readonly status: 'not-published'; readonly entries: readonly [] }
+  | {
+      readonly inputDefs: z.infer<typeof flowInputFieldsView>
+      readonly publication: Publication
+      readonly status: 'runnable' | 'suspended'
+      readonly enabled: boolean
+      readonly entries: readonly LiveEntry[]
+    }
+)
+
+/** Project only the selected published definition and its current bindings. */
+export function liveEntries(content: RevisionContent, current: Publication, bindings: readonly TriggerBinding[]): readonly LiveEntry[] {
+  const byNode = new Map(
+    bindings
+      .filter((item) => item.flowId == current.flowId && item.currentPublicationId == current.publicationId && item.currentRevisionId == current.revisionId)
+      .map((item) => [item.triggerNodeId, item]),
+  )
+  const entries = Object.entries(content.document.graph.nodes)
+    .toSorted(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    .flatMap(([nodeId, node]) => {
+      if (
+        node.kind != 'start' &&
+        node.kind != 'manual' &&
+        node.kind != 'webhook' &&
+        node.kind != 'cron' &&
+        node.kind != 'error' &&
+        node.kind != 'poll' &&
+        node.kind != 'integration'
+      )
+        return []
+      const config = triggerConfiguration(node)
+      const value = {
+        nodeId,
+        name: node.name,
+        type: node.kind,
+        ...(node.description == null ? {} : { description: node.description }),
+        config: node.kind == 'webhook' && !webhookSupportsBody(node.method) ? { ...config, body: {} } : config,
+        ...(node.kind == 'start' || node.kind == 'manual' ? {} : { binding: byNode.get(nodeId) }),
+        ...(node.kind == 'poll' || node.kind == 'integration' ? { provider: node.definition.provider, inputs: node.config } : {}),
+      }
+      return [value]
+    })
+  return decodeEntries(entries, current)
+}
+
+export function decodeLiveDetails(value: unknown): LiveDetails {
+  const source = record(value)
+  const flowId = string(source.flowId)
+  if (source.version != 1 || !Array.isArray(source.entries)) return invalidResponse()
+  if (source.publication === null) {
+    if (source.inputDefs !== null || source.status != 'not-published' || source.entries.length != 0 || Object.hasOwn(source, 'enabled'))
+      return invalidResponse()
+    return { flowId, inputDefs: null, publication: null, status: 'not-published', entries: [], version: 1 }
+  }
+  const current = publication(source.publication)
+  const status = source.status
+  if (current.flowId != flowId || typeof source.enabled != 'boolean') return invalidResponse()
+  if (status != 'runnable' && status != 'suspended') return invalidResponse()
+  if (!source.enabled && source.status == 'runnable') return invalidResponse()
+  const inputDefs = flowInputFieldsView.safeParse(source.inputDefs)
+  if (!inputDefs.success) return invalidResponse()
+  return {
+    flowId,
+    inputDefs: inputDefs.data,
+    publication: current,
+    status: status as 'runnable' | 'suspended',
+    enabled: source.enabled,
+    entries: decodeEntries(source.entries, current),
+    version: 1,
+  }
+}
+
+/** Both producers and consumers enforce the same published-entry invariants. */
+function decodeEntries(values: unknown, current: Publication): readonly LiveEntry[] {
+  const parsed = z.array(entrySchema).safeParse(values)
+  if (!parsed.success) return invalidResponse()
+  const ids = new Set<string>()
+  for (const entry of parsed.data) {
+    if (ids.has(entry.nodeId)) return invalidResponse()
+    ids.add(entry.nodeId)
+    if (
+      entry.type != 'start' &&
+      entry.type != 'manual' &&
+      (entry.binding.flowId != current.flowId ||
+        entry.binding.triggerNodeId != entry.nodeId ||
+        entry.binding.kind != entry.type ||
+        entry.binding.currentPublicationId != current.publicationId ||
+        entry.binding.currentRevisionId != current.revisionId)
+    )
+      return invalidResponse()
+    if (entry.type == 'webhook' && (!entry.binding.endpointUrl || (!webhookSupportsBody(entry.config.method) && Object.keys(entry.config.body).length > 0)))
+      return invalidResponse()
+  }
+  return parsed.data
+}