chore: import upstream snapshot with attribution

apps/sim/blocks/custom/build-config.ts

@@ -0,0 +1,197 @@
+import type { SubBlockType } from '@sim/workflow-types/blocks'
+import type { WorkflowInputField } from '@/lib/workflows/input-format'
+import type { BlockConfig, BlockIcon, SubBlockConfig } from '@/blocks/types'
+
+/**
+ * The block-type prefix that identifies a custom (deploy-as-block) block. Shared
+ * by the registry overlay, the executor handler dispatch, and access control.
+ */
+export const CUSTOM_BLOCK_TYPE_PREFIX = 'custom_block_'
+
+/** Whether a block type is a published custom block. */
+export function isCustomBlockType(type: string | undefined | null): type is string {
+  return typeof type === 'string' && type.startsWith(CUSTOM_BLOCK_TYPE_PREFIX)
+}
+
+/** Tile background for custom-block icons (the uploaded image renders on top). */
+export const CUSTOM_BLOCK_TILE_COLOR = '#6F6F6F'
+
+/** A curated output exposed on the block, mapped from a child block output. */
+export interface CustomBlockOutput {
+  blockId: string
+  path: string
+  name: string
+}
+
+/**
+ * A curated input the admin chose to expose on the block, keyed by the source
+ * Start field's stable `id`, with optional consumer-facing hints.
+ */
+export interface CustomBlockInput {
+  id: string
+  name: string
+  type: string
+  placeholder?: string
+  description?: string
+  required?: boolean
+}
+
+/**
+ * The DB-backed identity + presentation of a custom block. `workflowId` is the
+ * bound source workflow whose LATEST deployment this block always executes.
+ */
+export interface CustomBlockRow {
+  type: string
+  name: string
+  description: string
+  workflowId: string
+  /** Curated exposed outputs; empty/absent exposes the child's whole `result`. */
+  exposedOutputs?: CustomBlockOutput[]
+}
+
+/**
+ * Params that carry the block's own wiring rather than a mapped Start input.
+ * Everything else on the block is collected into the child `inputMapping`. Shared
+ * with the serializer so "does this custom block declare input sub-blocks?" reads
+ * from one source instead of re-listing the structural ids.
+ */
+export const RESERVED_PARAMS = new Set([
+  'workflowId',
+  'inputMapping',
+  'triggerMode',
+  'advancedMode',
+])
+
+/** Map a Start input field type to the editor sub-block type used to collect it. */
+function subBlockTypeForField(fieldType: string): SubBlockType {
+  switch (fieldType) {
+    case 'boolean':
+      return 'switch'
+    case 'object':
+    case 'array':
+      return 'code'
+    case 'file[]':
+      return 'file-upload'
+    default:
+      return 'short-input'
+  }
+}
+
+/**
+ * Synthesize a `BlockConfig` for a published custom block from its DB row and the
+ * live-derived Start input fields. Shared by the client (real icon + per-field
+ * editors) and the server (placeholder icon + `inputFields: []`, since the
+ * `inputMapping` wiring is schema-agnostic).
+ *
+ * Execution reuses the `workflow_executor` tool: the bound `workflowId` and the
+ * assembled `inputMapping` are hidden, baked sub-blocks; each Start input becomes
+ * its own editable sub-block whose value is collected into `inputMapping`.
+ * `<refs>` inside those values resolve at execution exactly like the
+ * `workflow_input` block.
+ *
+ * The sub-block id is the field's stable id (`field.id`), NOT its display name, so
+ * renaming a Start input in the source workflow and redeploying never orphans a
+ * consumer's placed value. The name is shown as the sub-block title and is what
+ * the child workflow ultimately receives — the id→name remap happens at execution
+ * in `WorkflowBlockHandler` against the loaded child's current field names. Legacy
+ * fields without an id fall back to keying on the name.
+ */
+export function buildCustomBlockConfig(
+  row: CustomBlockRow,
+  inputFields: WorkflowInputField[],
+  opts: { icon: BlockIcon; bgColor?: string; hideFromToolbar?: boolean }
+): BlockConfig {
+  const fieldSubBlocks: SubBlockConfig[] = inputFields.map((field) => {
+    const type = subBlockTypeForField(field.type)
+    const sub: SubBlockConfig = {
+      id: field.id ?? field.name,
+      title: field.name,
+      type,
+      description: field.description,
+      placeholder: field.placeholder,
+      // Serializer Loop-B (required subBlocks not covered by tool params) and the
+      // editor asterisk both read this — same enforcement path as regular blocks.
+      required: field.required === true,
+    }
+    if (field.type === 'object' || field.type === 'array') sub.language = 'json'
+    if (field.type === 'file[]') sub.multiple = true
+    return sub
+  })
+
+  return {
+    type: row.type,
+    name: row.name,
+    description: row.description,
+    category: 'tools',
+    longDescription:
+      'A published workflow packaged as a reusable, self-contained block. Fill its input ' +
+      'fields; it runs the underlying workflow and returns the outputs below. The bound ' +
+      'workflow is baked in — no workflow id or input mapping to configure.',
+    bgColor: opts.bgColor ?? CUSTOM_BLOCK_TILE_COLOR,
+    icon: opts.icon,
+    // A disabled block stays resolvable (so a still-placed instance survives
+    // serialization and fails loudly at run via `getCustomBlockAuthority`, instead
+    // of silently vanishing from the graph) but is hidden from the palette so no
+    // new instance can be placed.
+    hideFromToolbar: opts.hideFromToolbar,
+    subBlocks: [
+      {
+        id: 'workflowId',
+        type: 'short-input',
+        hidden: true,
+        value: () => row.workflowId,
+      },
+      {
+        id: 'inputMapping',
+        type: 'code',
+        language: 'json',
+        hidden: true,
+        value: (params) => {
+          const mapping: Record<string, unknown> = {}
+          for (const [key, val] of Object.entries(params)) {
+            if (RESERVED_PARAMS.has(key)) continue
+            if (val === undefined || val === '') continue
+            mapping[key] = val
+          }
+          return JSON.stringify(mapping)
+        },
+      },
+      ...fieldSubBlocks,
+    ],
+    tools: {
+      access: ['workflow_executor'],
+      config: {
+        tool: () => 'workflow_executor',
+        params: (params) => ({
+          workflowId: params.workflowId,
+          inputMapping: params.inputMapping,
+        }),
+      },
+    },
+    inputs: {
+      workflowId: { type: 'string', description: 'Bound source workflow id' },
+      inputMapping: { type: 'json', description: 'Mapping of input fields to values' },
+    },
+    outputs: buildOutputs(row.exposedOutputs),
+  }
+}
+
+/**
+ * The block's declared outputs. Internal plumbing (child workflow id/name, trace
+ * spans) is never exposed. With curated `exposedOutputs`, each becomes its own
+ * named output; otherwise the whole child `result` is exposed.
+ */
+function buildOutputs(exposed: CustomBlockOutput[] | undefined): BlockConfig['outputs'] {
+  const outputs: BlockConfig['outputs'] = {
+    success: { type: 'boolean', description: 'Execution success status' },
+    error: { type: 'string', description: 'Error message' },
+  }
+  if (exposed && exposed.length > 0) {
+    for (const out of exposed) {
+      outputs[out.name] = { type: 'json', description: `Output: ${out.path}` }
+    }
+  } else {
+    outputs.result = { type: 'json', description: 'Workflow execution result' }
+  }
+  return outputs
+}