diff --git a/.changeset/schema-filter.md b/.changeset/schema-filter.md
new file mode 100644
index 00000000..309d41fd
--- /dev/null
+++ b/.changeset/schema-filter.md
@@ -0,0 +1,5 @@
+---
+"@openworkflowspec/diagram-editor": minor
+---
+
+Add filter schema by definiton capabilities.
diff --git a/packages/open-workflow-diagram-editor/package.json b/packages/open-workflow-diagram-editor/package.json
index f78d9e7b..2b613b71 100644
--- a/packages/open-workflow-diagram-editor/package.json
+++ b/packages/open-workflow-diagram-editor/package.json
@@ -45,6 +45,7 @@
     "@openworkflowspec/i18n": "workspace:*",
     "@openworkflowspec/sdk": "catalog:",
     "@xyflow/react": "catalog:",
+    "allof-merge": "catalog:",
     "class-variance-authority": "catalog:",
     "clsx": "catalog:",
     "elkjs": "catalog:",
diff --git a/packages/open-workflow-diagram-editor/src/core/index.ts b/packages/open-workflow-diagram-editor/src/core/index.ts
index c4e14a99..93723d14 100644
--- a/packages/open-workflow-diagram-editor/src/core/index.ts
+++ b/packages/open-workflow-diagram-editor/src/core/index.ts
@@ -22,5 +22,6 @@ export * from "./taskDetails";
 export * from "./taskSubType";
 export * from "./elkjs";
 export * from "./mermaidExport";
+export * from "./schemaFilter";
 /* TEMPORARY — remove with the workaround; see the revert checklist in workflowSdk.ts. */
 export * from "./specWorkarounds";
diff --git a/packages/open-workflow-diagram-editor/src/core/schemaFilter.ts b/packages/open-workflow-diagram-editor/src/core/schemaFilter.ts
new file mode 100644
index 00000000..a687444e
--- /dev/null
+++ b/packages/open-workflow-diagram-editor/src/core/schemaFilter.ts
@@ -0,0 +1,416 @@
+/*
+ * Copyright 2021-Present The Open Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { merge } from "allof-merge";
+import { workflowSchema } from "@openworkflowspec/sdk";
+
+/* A fully dereferenced, self-contained JSON schema object.
+ * All $ref pointers have been replaced and allOf compositions merged. */
+export type DereferencedSchema = Record<string, unknown>;
+
+// ---------------------------------------------------------------------------
+// Module-level constants and caches
+// ---------------------------------------------------------------------------
+
+let _merged: Record<string, unknown> | null = null;
+const _definitionCache = new Map<string, DereferencedSchema>();
+
+// Both caches are populated together on first use by initTaskBaseCache().
+let _taskBaseTitles: Set<string> | null = null;
+let _taskBaseKeys: Set<string> | null = null;
+
+function getMergedSchema(): Record<string, unknown> {
+  if (_merged === null) {
+    _merged = merge(workflowSchema, { source: workflowSchema }) as Record<string, unknown>;
+  }
+  return _merged;
+}
+
+/**
+ * Lazily initialises `_taskBaseTitles` and `_taskBaseKeys` from the raw schema
+ * in a single pass over `taskBase.properties`. Both sets are derived from the
+ * same source so they are always computed together.
+ */
+function initTaskBaseCache(): void {
+  if (_taskBaseTitles !== null) return;
+
+  const rawDefs = workflowSchema.$defs as Record<string, unknown>;
+  const taskBase = rawDefs["taskBase"] as Record<string, unknown> | undefined;
+  const props = taskBase?.["properties"] as Record<string, Record<string, unknown>> | undefined;
+
+  const titles = new Set<string>();
+  const keys = new Set<string>(props ? Object.keys(props) : []);
+
+  if (props) {
+    for (const propSchema of Object.values(props)) {
+      if (typeof propSchema?.["title"] === "string") {
+        titles.add(propSchema["title"] as string);
+      }
+      const oneOf = propSchema?.["oneOf"] as Array<Record<string, unknown>> | undefined;
+      if (Array.isArray(oneOf)) {
+        for (const variant of oneOf) {
+          if (typeof variant?.["title"] === "string") titles.add(variant["title"] as string);
+        }
+      }
+    }
+  }
+
+  _taskBaseTitles = titles;
+  _taskBaseKeys = keys;
+}
+
+// ---------------------------------------------------------------------------
+// Derived structural defs
+// ---------------------------------------------------------------------------
+
+let _structuralDefs: Set<string> | null = null;
+
+/**
+ * Lazily derives the set of "structural" definition names from the raw schema.
+ *
+ * Two structural patterns are recognised, both derived directly from the schema:
+ *
+ * 1. **Task mixins** — entries that appear as a bare `$ref` inside a top-level
+ *    `allOf` of a concrete task definition (or inside each `oneOf` variant for
+ *    discriminated-union tasks like `callTask`). Currently this is `taskBase`.
+ *
+ * 2. **Task-list wrappers** — `type: array` entries whose
+ *    `items.additionalProperties.$ref` points to the `task` union. This
+ *    captures `taskList` without naming it explicitly.
+ *
+ * No definition names are hardcoded. If the schema introduces a new mixin or
+ * wrapper that fits either pattern, it is automatically excluded.
+ */
+function getStructuralDefs(): Set<string> {
+  if (_structuralDefs !== null) return _structuralDefs;
+
+  const rawDefs = workflowSchema.$defs as Record<string, unknown>;
+  _structuralDefs = new Set<string>();
+
+  // ── Pattern 1: task mixins ────────────────────────────────────────────────
+  // Collect every $ref that appears as a direct allOf entry at the root of a
+  // concrete task definition, or at the root of each oneOf variant for
+  // discriminated-union tasks. These are shared base objects, not task types.
+  function collectTopLevelAllOfRefs(def: Record<string, unknown>): void {
+    const allOf = def["allOf"] as Array<Record<string, unknown>> | undefined;
+    if (Array.isArray(allOf)) {
+      for (const entry of allOf) {
+        const ref = entry["$ref"];
+        if (
+          typeof ref === "string" &&
+          ref.startsWith("#/$defs/") &&
+          Object.keys(entry).length === 1
+        ) {
+          _structuralDefs!.add(ref.slice("#/$defs/".length));
+        }
+      }
+    }
+    // For union tasks (e.g. callTask) whose top level is a oneOf, recurse into
+    // each variant to find its allOf base refs.
+    const oneOf = def["oneOf"] as Array<Record<string, unknown>> | undefined;
+    if (Array.isArray(oneOf)) {
+      for (const variant of oneOf) {
+        collectTopLevelAllOfRefs(variant);
+      }
+    }
+  }
+
+  for (const name of Object.keys(rawDefs)) {
+    const def = rawDefs[name] as Record<string, unknown>;
+    collectTopLevelAllOfRefs(def);
+  }
+
+  // ── Pattern 2: task-list wrappers ─────────────────────────────────────────
+  // An array definition whose items use additionalProperties.$ref pointing to
+  // the task union is a structural container, not a domain type.
+  const TASK_REF = "#/$defs/task";
+  for (const [name, def] of Object.entries(rawDefs)) {
+    const d = def as Record<string, unknown>;
+    if (d["type"] !== "array") continue;
+    const items = d["items"] as Record<string, unknown> | undefined;
+    if (!items) continue;
+    const additionalProps = items["additionalProperties"] as Record<string, unknown> | undefined;
+    if (additionalProps?.["$ref"] === TASK_REF) {
+      _structuralDefs.add(name);
+    }
+  }
+
+  return _structuralDefs;
+}
+
+// ---------------------------------------------------------------------------
+// Public helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns the names of `$defs` entries directly referenced by a definition
+ * in the raw schema, excluding structural scaffolding (e.g. `taskBase`, `taskList`).
+ *
+ * These are the meaningful domain sub-definitions a consumer may want to
+ * resolve independently — e.g. `retryPolicy` inside `tryTask`,
+ * `eventConsumptionStrategy` inside `listenTask`, or `endpoint` inside
+ * `callTask`. Inherited `taskBase` refs are excluded because they are
+ * structural, not task-specific.
+ *
+ * Operates on the raw (unmerged) schema so results are independent of whether
+ * `getSchemaForDefinition` has been called.
+ */
+export function getReferencedDefinitions(definitionName: string): string[] {
+  const rawDefs = workflowSchema.$defs as Record<string, unknown>;
+  const node = rawDefs[definitionName];
+  if (node === undefined) return [];
+
+  const found = new Set<string>();
+
+  function collect(obj: unknown): void {
+    if (Array.isArray(obj)) {
+      obj.forEach(collect);
+      return;
+    }
+    if (obj !== null && typeof obj === "object") {
+      const rec = obj as Record<string, unknown>;
+      const ref = rec["$ref"];
+      if (typeof ref === "string" && ref.startsWith("#/$defs/")) {
+        const name = ref.slice("#/$defs/".length);
+        if (!getStructuralDefs().has(name)) found.add(name);
+      }
+      Object.values(rec).forEach(collect);
+    }
+  }
+
+  collect(node);
+  return [...found].sort();
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Recursively deep clones a value, breaking cyclic references without
+ * dropping non-cyclic shared nodes (DAG structures).
+ *
+ * The `stack` tracks the active ancestor path so true cycles (an object that
+ * contains itself) are detected and broken by returning `undefined`, while
+ * sibling nodes that happen to reference the same object are still cloned
+ * normally.
+ *
+ * @param value - The value to deep clone.
+ * @param stack - Active ancestor stack; callers should omit this (uses default).
+ * @returns A deep clone of the value with any cycles removed.
+ */
+function cloneDeepSafe(value: unknown, stack = new Set<object>()): unknown {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+
+  // Detect and break cycles
+  if (stack.has(value as object)) {
+    return undefined;
+  }
+
+  stack.add(value as object);
+
+  if (Array.isArray(value)) {
+    const clone: unknown[] = [];
+    for (const item of value) {
+      const clonedItem = cloneDeepSafe(item, stack);
+      if (clonedItem !== undefined) {
+        clone.push(clonedItem);
+      }
+    }
+    stack.delete(value as object);
+    return clone;
+  }
+
+  const clone: Record<string, unknown> = {};
+  for (const [key, val] of Object.entries(value)) {
+    const clonedVal = cloneDeepSafe(val, stack);
+    if (clonedVal !== undefined) {
+      clone[key] = clonedVal;
+    }
+  }
+  stack.delete(value as object);
+  return clone;
+}
+
+/**
+ * Recursively collects every `#/$defs/<name>` reference name found anywhere
+ * inside `node`, including transitively through referenced definitions.
+ *
+ * Uses a `WeakSet` to track already-visited objects so that circular
+ * references in the merged schema (e.g. `eventConsumptionStrategy`, which
+ * `allof-merge` can represent as a shared object cycle) do not cause a stack
+ * overflow. The `visitedNames` set prevents re-scanning defs we've already
+ * queued.
+ *
+ * @param root - The schema node to scan.
+ * @param mergedDefs - The full `$defs` block map.
+ * @returns A set of transitive definition reference names.
+ */
+function collectTransitiveRefs(root: unknown, mergedDefs: Record<string, unknown>): Set<string> {
+  const visitedNames = new Set<string>();
+  const visitedObjs = new WeakSet<object>();
+
+  function scan(node: unknown): void {
+    if (Array.isArray(node)) {
+      node.forEach(scan);
+      return;
+    }
+    if (node !== null && typeof node === "object") {
+      if (visitedObjs.has(node as object)) return;
+      visitedObjs.add(node as object);
+      const rec = node as Record<string, unknown>;
+      const ref = rec["$ref"];
+      if (typeof ref === "string" && ref.startsWith("#/$defs/")) {
+        const name = ref.slice("#/$defs/".length);
+        if (!visitedNames.has(name)) {
+          visitedNames.add(name);
+          scan(mergedDefs[name]);
+        }
+      }
+      Object.values(rec).forEach(scan);
+    }
+  }
+
+  scan(root);
+  return visitedNames;
+}
+
+/**
+ * Re-orders a `properties` map in-place so that task-own keys come before
+ * `taskBase`-inherited keys. This ensures form generators iterate the
+ * task-specific fields first.
+ *
+ * @param properties - A mutable `properties` object from a merged schema node.
+ * @param baseKeys   - The set of property names inherited from `taskBase`.
+ */
+function reorderProperties(properties: Record<string, unknown>, baseKeys: Set<string>): void {
+  // Single pass: collect base entries and check if there is anything to reorder.
+  const baseEntries: [string, unknown][] = [];
+  let hasOwnKey = false;
+  for (const k of Object.keys(properties)) {
+    if (baseKeys.has(k)) {
+      baseEntries.push([k, properties[k]]);
+    } else {
+      hasOwnKey = true;
+    }
+  }
+  if (!hasOwnKey || baseEntries.length === 0) return;
+
+  // Delete base keys from their current (leading) position and re-append them.
+  for (const [k] of baseEntries) delete properties[k];
+  for (const [k, v] of baseEntries) properties[k] = v;
+}
+
+/**
+ * Strips `title` values inherited from `taskBase` property schemas and
+ * reorders each `properties` map so task-own fields come before inherited
+ * `taskBase` fields.
+ */
+function transformSchema(node: unknown): void {
+  initTaskBaseCache();
+  const titles = _taskBaseTitles!;
+  const baseKeys = _taskBaseKeys!;
+
+  const visited = new WeakSet<object>();
+
+  function walk(current: unknown): void {
+    if (current === null || typeof current !== "object") return;
+    if (visited.has(current as object)) return;
+    visited.add(current as object);
+
+    if (Array.isArray(current)) {
+      for (const item of current) walk(item);
+      return;
+    }
+
+    const rec = current as Record<string, unknown>;
+    if (typeof rec["title"] === "string" && titles.has(rec["title"] as string)) {
+      delete rec["title"];
+    }
+    if (
+      rec["properties"] !== null &&
+      typeof rec["properties"] === "object" &&
+      !Array.isArray(rec["properties"])
+    ) {
+      reorderProperties(rec["properties"] as Record<string, unknown>, baseKeys);
+    }
+    for (const value of Object.values(rec)) walk(value);
+  }
+
+  walk(node);
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolves a named definition from the workflow schema into a **fully formed,
+ * self-contained JSON Schema object**.
+ *
+ * The full schema is merged once via `allof-merge`, which flattens `allOf`
+ * compositions so inherited `taskBase` fields are inlined directly into the
+ * task's `properties` alongside its own fields. Each `oneOf` variant is also
+ * flattened individually.
+ *
+ * The returned object includes a `$defs` block with every transitively
+ * referenced definition so that remaining `$ref` pointers can be resolved
+ * without access to the full schema. Task-own properties are ordered before
+ * inherited `taskBase` properties within each `properties` map.
+ *
+ * Results are cached per definition name; the merge itself is computed once.
+ *
+ * @param definitionName - Key from `$defs`, e.g. `"setTask"`, `"callTask"`.
+ * @returns A self-contained, allOf-flattened schema for the requested definition.
+ * @throws {Error} If the definition does not exist in the schema.
+ */
+export function getSchemaForDefinition(definitionName: string): DereferencedSchema {
+  const cached = _definitionCache.get(definitionName);
+  if (cached !== undefined) return cached;
+
+  const merged = getMergedSchema();
+  const defs = merged["$defs"] as Record<string, unknown> | undefined;
+  const definition = defs?.[definitionName];
+
+  if (definition === undefined) {
+    throw new Error(`Definition "${definitionName}" not found in workflow schema $defs.`);
+  }
+
+  const referencedNames = collectTransitiveRefs(definition, defs!);
+  const definitionClone = cloneDeepSafe(definition) as Record<string, unknown>;
+
+  let result: Record<string, unknown>;
+  if (referencedNames.size > 0) {
+    const bundledDefs: Record<string, unknown> = {};
+    for (const name of referencedNames) {
+      if (defs![name] !== undefined) {
+        bundledDefs[name] = cloneDeepSafe(defs![name]);
+      }
+    }
+    // Place the definition's own keys first so they lead when the object is
+    // iterated; $defs is appended at the end as supporting material.
+    result = { ...definitionClone, $defs: bundledDefs };
+  } else {
+    result = definitionClone;
+  }
+
+  transformSchema(result);
+
+  _definitionCache.set(definitionName, result);
+  return result;
+}
diff --git a/packages/open-workflow-diagram-editor/stories/features/SchemaFilter.stories.tsx b/packages/open-workflow-diagram-editor/stories/features/SchemaFilter.stories.tsx
new file mode 100644
index 00000000..1a805590
--- /dev/null
+++ b/packages/open-workflow-diagram-editor/stories/features/SchemaFilter.stories.tsx
@@ -0,0 +1,352 @@
+/*
+ * Copyright 2021-Present The Open Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { useState } from "react";
+import type { Meta, StoryObj } from "@storybook/react-vite";
+import { getSchemaForDefinition, getReferencedDefinitions } from "../../src/core/schemaFilter";
+
+// ---------------------------------------------------------------------------
+// Task definitions available in the schema
+// ---------------------------------------------------------------------------
+
+/** All task definition names exposed in the first combo. */
+const TASK_DEFINITIONS: string[] = [
+  "callTask",
+  "doTask",
+  "emitTask",
+  "forTask",
+  "forkTask",
+  "listenTask",
+  "raiseTask",
+  "runTask",
+  "setTask",
+  "switchTask",
+  "tryTask",
+  "waitTask",
+];
+
+// ---------------------------------------------------------------------------
+// Inline styles
+// ---------------------------------------------------------------------------
+
+const containerStyle: React.CSSProperties = {
+  fontFamily: "inherit",
+  fontSize: "14px",
+  padding: "24px",
+  display: "flex",
+  flexDirection: "column",
+  gap: "16px",
+  maxWidth: "860px",
+};
+
+const rowStyle: React.CSSProperties = {
+  display: "flex",
+  alignItems: "center",
+  gap: "12px",
+  flexWrap: "wrap",
+};
+
+const labelStyle: React.CSSProperties = {
+  fontWeight: 600,
+  minWidth: "80px",
+};
+
+const selectStyle: React.CSSProperties = {
+  padding: "6px 10px",
+  borderRadius: "6px",
+  border: "1px solid #d1d5db",
+  fontSize: "14px",
+  fontFamily: "inherit",
+  background: "#fff",
+  color: "#1f2328",
+  minWidth: "220px",
+  cursor: "pointer",
+};
+
+const buttonStyle: React.CSSProperties = {
+  padding: "6px 16px",
+  height: "34px",
+  fontSize: "13px",
+  fontFamily: "inherit",
+  fontWeight: 600,
+  cursor: "pointer",
+  borderRadius: "6px",
+  border: "1px solid #d1d5db",
+  background: "linear-gradient(to bottom, #ffffff, #f3f4f6)",
+  color: "#374151",
+  transition: "opacity 60ms",
+};
+
+const disabledButtonStyle: React.CSSProperties = {
+  ...buttonStyle,
+  opacity: 0.4,
+  cursor: "not-allowed",
+};
+
+const textareaStyle: React.CSSProperties = {
+  width: "100%",
+  minHeight: "420px",
+  padding: "12px",
+  fontSize: "12px",
+  fontFamily: "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace",
+  lineHeight: 1.6,
+  borderRadius: "6px",
+  border: "1px solid #d1d5db",
+  background: "#f7f8fa",
+  color: "#1f2328",
+  resize: "vertical",
+  boxSizing: "border-box",
+};
+
+const errorStyle: React.CSSProperties = {
+  color: "#dc2626",
+  fontSize: "13px",
+};
+
+const hintStyle: React.CSSProperties = {
+  fontSize: "12px",
+  color: "#6b7280",
+  marginTop: "-8px",
+};
+
+// ---------------------------------------------------------------------------
+// Story component
+// ---------------------------------------------------------------------------
+
+function SchemaFilterStory() {
+  const [taskDef, setTaskDef] = useState<string>("callTask");
+  const [subType, setSubType] = useState<string>("");
+  const [schemaJson, setSchemaJson] = useState<string>("");
+  const [error, setError] = useState<string>("");
+  const [copied, setCopied] = useState(false);
+
+  /* Recalculate sub-types whenever the task changes. */
+  const currentSubTypes = getReferencedDefinitions(taskDef);
+
+  const handleTaskChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
+    const newTask = e.target.value;
+    setTaskDef(newTask);
+    setSubType("");
+    setSchemaJson("");
+    setError("");
+  };
+
+  const handleSubTypeChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
+    setSubType(e.target.value);
+    setSchemaJson("");
+    setError("");
+  };
+
+  const handleGetSchema = () => {
+    setError("");
+    setSchemaJson("");
+    try {
+      /* If a sub-type (referenced def name) is selected, resolve that def
+       * directly instead of the parent task. */
+      const target = subType || taskDef;
+      const schema = getSchemaForDefinition(target);
+      setSchemaJson(JSON.stringify(schema, null, 2));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    }
+  };
+
+  const handleCopy = async () => {
+    try {
+      await navigator.clipboard.writeText(schemaJson);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2000);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    }
+  };
+
+  return (
+    <div style={containerStyle}>
+      {/* Task combo */}
+      <div style={rowStyle}>
+        <label style={labelStyle} htmlFor="task-select">
+          Task
+        </label>
+        <select id="task-select" style={selectStyle} value={taskDef} onChange={handleTaskChange}>
+          {TASK_DEFINITIONS.map((name) => (
+            <option key={name} value={name}>
+              {name}
+            </option>
+          ))}
+        </select>
+      </div>
+
+      {/* Sub-type combo */}
+      <div style={rowStyle}>
+        <label style={labelStyle} htmlFor="subtype-select">
+          Sub-type
+        </label>
+        <select
+          id="subtype-select"
+          style={{
+            ...selectStyle,
+            color: currentSubTypes.length === 0 ? "#9ca3af" : selectStyle.color,
+          }}
+          value={subType}
+          onChange={handleSubTypeChange}
+          disabled={currentSubTypes.length === 0}
+        >
+          <option value="">— full task schema —</option>
+          {currentSubTypes.map((name) => (
+            <option key={name} value={name}>
+              {name}
+            </option>
+          ))}
+        </select>
+      </div>
+
+      {currentSubTypes.length > 0 && (
+        <p style={hintStyle}>
+          Select a sub-type to resolve only that definition's schema, or leave empty to get the full{" "}
+          <strong>{taskDef}</strong> schema.
+        </p>
+      )}
+
+      {/* Get Schema button */}
+      <div style={rowStyle}>
+        <button style={buttonStyle} onClick={handleGetSchema}>
+          Get Schema
+        </button>
+      </div>
+
+      {/* Error */}
+      {error && <p style={errorStyle}>Error: {error}</p>}
+
+      {/* Output textarea */}
+      <textarea
+        readOnly
+        style={textareaStyle}
+        value={schemaJson}
+        placeholder="Resolved JSON schema will appear here…"
+        aria-label="Resolved JSON schema output"
+      />
+
+      {/* Copy button */}
+      <div style={rowStyle}>
+        <button
+          style={schemaJson ? buttonStyle : disabledButtonStyle}
+          onClick={handleCopy}
+          disabled={!schemaJson}
+        >
+          {copied ? "Copied!" : "Copy to Clipboard"}
+        </button>
+      </div>
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Storybook meta
+// ---------------------------------------------------------------------------
+
+const meta = {
+  title: "Features/Schema Filter",
+  component: SchemaFilterStory,
+  tags: ["autodocs"],
+  parameters: {
+    layout: "padded",
+    docs: {
+      description: {
+        component: `
+## Schema Filter — \`getSchemaForDefinition\`
+
+\`getSchemaForDefinition\` resolves any named definition from the bundled
+\`workflow.json\` schema into a **fully formed, self-contained JSON Schema
+object**. Every \`allOf\` composition is merged — including the shared
+\`taskBase\` fields inherited by all tasks — and all transitive \`$ref\`
+dependencies are bundled inline, so the result can be handed directly to
+a validator or documentation renderer with no further processing.
+
+---
+
+## Usage
+
+The function is **synchronous**. The full schema merge is computed once on the
+first call and cached at module level; all subsequent calls are O(1) lookups.
+
+\`\`\`ts
+// Resolve the full schema for the "setTask" definition
+const schema = getSchemaForDefinition("setTask");
+
+// schema is a plain Record<string, unknown> — no allOf remaining.
+// Every field is inlined, including the inherited taskBase properties:
+// schema.properties => { if, input, output, export, timeout, then, metadata, set }
+\`\`\`
+
+---
+
+## Resolving a sub-definition
+
+\`getReferencedDefinitions\` returns the names of all \`$defs\` entries that a
+given task directly references (excluding structural scaffolding like
+\`taskBase\` and \`taskList\`). Pass any of those names back to
+\`getSchemaForDefinition\` to get a fully resolved, standalone schema for that
+sub-definition.
+
+\`\`\`ts
+// Which named sub-definitions does tryTask reference?
+const subDefs = getReferencedDefinitions("tryTask");
+// => ["errorFilter", "retryPolicy"]
+
+// Resolve the retryPolicy schema on its own
+const retryPolicySchema = getSchemaForDefinition("retryPolicy");
+\`\`\`
+
+This pattern is also useful for \`callTask\`, which references \`endpoint\`,
+\`externalResource\`, \`asyncApiServer\`, and more:
+
+\`\`\`ts
+const subDefs = getReferencedDefinitions("callTask");
+// => ["asyncApiServer", "asyncApiSubscription", "duration",
+//     "endpoint", "externalResource", "referenceableAuthenticationPolicy",
+//     "runtimeExpression"]
+
+const endpointSchema = getSchemaForDefinition("endpoint");
+\`\`\`
+
+---
+
+## How it works
+
+1. **Import** — the workflow schema is imported from the \`@openworkflowspec/sdk\`
+   package as a static ES module at build time — no file I/O at runtime.
+
+2. **Merge** — on the first call, \`allof-merge\` runs a single pass over the
+   full schema. This resolves every \`$ref\` inside \`allOf\` compositions and
+   flattens them into the parent object — including the shared \`taskBase\` fields
+   inherited by all tasks. The result is stored in a module-level cache.
+
+3. **Extract & bundle** — the requested entry is looked up from \`$defs\` of the
+   merged schema. Its transitive \`$ref\` dependencies are collected and
+   deep-cloned into a \`$defs\` block on the result, so the output is fully
+   self-contained without requiring access to the original full schema.
+
+`,
+      },
+    },
+  },
+} satisfies Meta<typeof SchemaFilterStory>;
+
+export default meta;
+type Story = StoryObj<typeof meta>;
+
+export const SchemaFilter: Story = {};
diff --git a/packages/open-workflow-diagram-editor/tests/core/schemaFilter.test.ts b/packages/open-workflow-diagram-editor/tests/core/schemaFilter.test.ts
new file mode 100644
index 00000000..5a438e7f
--- /dev/null
+++ b/packages/open-workflow-diagram-editor/tests/core/schemaFilter.test.ts
@@ -0,0 +1,335 @@
+/*
+ * Copyright 2021-Present The Open Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, expect, it } from "vitest";
+import { getSchemaForDefinition, getReferencedDefinitions } from "../../src/core/schemaFilter";
+
+// ---------------------------------------------------------------------------
+// getSchemaForDefinition
+// ---------------------------------------------------------------------------
+
+describe("getSchemaForDefinition", () => {
+  describe("allOf flattening — taskBase fields are merged into every task", () => {
+    /* The shared base fields that every task definition inherits via
+     * allOf: [{ $ref: "#/$defs/taskBase" }, { ... task-specific ... }] */
+    const TASK_BASE_PROPS = ["if", "input", "output", "export", "timeout", "then", "metadata"];
+
+    it.each([
+      "callTask",
+      "doTask",
+      "emitTask",
+      "forTask",
+      "forkTask",
+      "listenTask",
+      "raiseTask",
+      "runTask",
+      "setTask",
+      "switchTask",
+      "tryTask",
+      "waitTask",
+    ] as const)(
+      "%s has all taskBase properties at the top level (no allOf remaining)",
+      (taskName) => {
+        const schema = getSchemaForDefinition(taskName);
+
+        expect(schema, `${taskName} should be an object`).toBeTypeOf("object");
+        expect("allOf" in schema, `${taskName} should have no allOf after merge`).toBe(false);
+
+        const properties = schema["properties"] as Record<string, unknown> | undefined;
+
+        if (taskName === "callTask") {
+          /* callTask is a oneOf discriminated union — base fields live inside
+           * each variant, not at the top level. */
+          expect(Array.isArray(schema["oneOf"]), "callTask should have oneOf").toBe(true);
+        } else {
+          expect(properties, `${taskName} should have properties`).toBeDefined();
+          for (const prop of TASK_BASE_PROPS) {
+            expect(prop in properties!, `${taskName}.properties should contain "${prop}"`).toBe(
+              true,
+            );
+          }
+        }
+      },
+    );
+  });
+
+  describe("task-specific fields are present alongside taskBase fields", () => {
+    it("setTask has 'set' in properties", () => {
+      const schema = getSchemaForDefinition("setTask");
+      const properties = schema["properties"] as Record<string, unknown>;
+      expect("set" in properties).toBe(true);
+    });
+
+    it("tryTask has 'try' and 'catch' in properties", () => {
+      const schema = getSchemaForDefinition("tryTask");
+      const properties = schema["properties"] as Record<string, unknown>;
+      expect("try" in properties).toBe(true);
+      expect("catch" in properties).toBe(true);
+    });
+
+    it("forkTask has 'fork' in properties", () => {
+      const schema = getSchemaForDefinition("forkTask");
+      const properties = schema["properties"] as Record<string, unknown>;
+      expect("fork" in properties).toBe(true);
+    });
+
+    it("waitTask has 'wait' in properties and correct required array", () => {
+      const schema = getSchemaForDefinition("waitTask");
+      const properties = schema["properties"] as Record<string, unknown>;
+      expect("wait" in properties).toBe(true);
+      expect(schema["required"]).toContain("wait");
+    });
+
+    it("forTask has 'for' and 'do' in properties", () => {
+      const schema = getSchemaForDefinition("forTask");
+      const properties = schema["properties"] as Record<string, unknown>;
+      expect("for" in properties).toBe(true);
+      expect("do" in properties).toBe(true);
+    });
+  });
+
+  describe("title is the task's own title, not 'TaskBase'", () => {
+    it.each([
+      ["setTask", "SetTask"],
+      ["tryTask", "TryTask"],
+      ["waitTask", "WaitTask"],
+      ["forkTask", "ForkTask"],
+      ["doTask", "DoTask"],
+      ["emitTask", "EmitTask"],
+      ["forTask", "ForTask"],
+      ["listenTask", "ListenTask"],
+      ["raiseTask", "RaiseTask"],
+      ["runTask", "RunTask"],
+      ["switchTask", "SwitchTask"],
+    ] as const)("%s has title '%s'", (taskName, expectedTitle) => {
+      const schema = getSchemaForDefinition(taskName);
+      expect(schema["title"]).toBe(expectedTitle);
+    });
+  });
+
+  describe("callTask oneOf variants", () => {
+    it("has a oneOf array with named variants", () => {
+      const schema = getSchemaForDefinition("callTask");
+      const oneOf = schema["oneOf"] as Array<Record<string, unknown>>;
+      expect(Array.isArray(oneOf)).toBe(true);
+      expect(oneOf.length).toBeGreaterThan(0);
+    });
+
+    it("each callTask variant has taskBase fields inlined (no allOf)", () => {
+      const schema = getSchemaForDefinition("callTask");
+      const oneOf = schema["oneOf"] as Array<Record<string, unknown>>;
+
+      for (const variant of oneOf) {
+        expect("allOf" in variant, `variant "${variant["title"]}" should have no allOf`).toBe(
+          false,
+        );
+        const props = variant["properties"] as Record<string, unknown> | undefined;
+        expect(props, `variant "${variant["title"]}" should have properties`).toBeDefined();
+        expect("if" in props!, `variant "${variant["title"]}" should have "if" from taskBase`).toBe(
+          true,
+        );
+        expect("call" in props!, `variant "${variant["title"]}" should have "call"`).toBe(true);
+      }
+    });
+
+    it("includes expected variant titles", () => {
+      const schema = getSchemaForDefinition("callTask");
+      const oneOf = schema["oneOf"] as Array<Record<string, unknown>>;
+      const titles = oneOf.map((v) => v["title"]);
+      expect(titles).toContain("CallHTTP");
+      expect(titles).toContain("CallGRPC");
+      expect(titles).toContain("CallAsyncAPI");
+      expect(titles).toContain("CallOpenAPI");
+    });
+  });
+
+  describe("non-task definitions", () => {
+    it("retryPolicy resolves with correct shape", () => {
+      const schema = getSchemaForDefinition("retryPolicy");
+      expect(schema["title"]).toBe("RetryPolicy");
+      expect(schema["type"]).toBe("object");
+      const properties = schema["properties"] as Record<string, unknown>;
+      expect("delay" in properties).toBe(true);
+      expect("limit" in properties).toBe(true);
+      expect("backoff" in properties).toBe(true);
+    });
+
+    it("taskBase resolves and has all base property keys", () => {
+      const schema = getSchemaForDefinition("taskBase");
+      const properties = schema["properties"] as Record<string, unknown>;
+      expect("if" in properties).toBe(true);
+      expect("input" in properties).toBe(true);
+      expect("output" in properties).toBe(true);
+      expect("timeout" in properties).toBe(true);
+      expect("then" in properties).toBe(true);
+    });
+
+    it("asyncApiInboundMessage merges asyncApiOutboundMessage fields (no allOf remaining)", () => {
+      /* asyncApiInboundMessage uses allOf: [{ $ref: asyncApiOutboundMessage }, { properties: { correlationId } }]
+       * After merging, the result must be flat: no allOf, and all three properties present. */
+      const schema = getSchemaForDefinition("asyncApiInboundMessage");
+      expect("allOf" in schema, "allOf should be gone after merge").toBe(false);
+      const properties = schema["properties"] as Record<string, unknown>;
+      expect("payload" in properties, "inherited from asyncApiOutboundMessage").toBe(true);
+      expect("headers" in properties, "inherited from asyncApiOutboundMessage").toBe(true);
+      expect("correlationId" in properties, "own field of asyncApiInboundMessage").toBe(true);
+    });
+  });
+
+  describe("$defs bundling — surviving $refs are resolvable without the original schema", () => {
+    it("callTask result includes a $defs block", () => {
+      const schema = getSchemaForDefinition("callTask");
+      expect(schema["$defs"], "callTask should have a bundled $defs block").toBeDefined();
+    });
+
+    it("callTask $defs contains 'input' so validators can resolve #/$defs/input", () => {
+      const schema = getSchemaForDefinition("callTask");
+      const defs = schema["$defs"] as Record<string, unknown>;
+      expect("input" in defs, "$defs should contain 'input'").toBe(true);
+    });
+
+    it("callTask $defs contains all transitive dependencies of 'input'", () => {
+      /* input.$ref -> schema -> externalResource — all must be present */
+      const schema = getSchemaForDefinition("callTask");
+      const defs = schema["$defs"] as Record<string, unknown>;
+      expect("schema" in defs, "$defs should contain 'schema' (used by input)").toBe(true);
+      expect(
+        "externalResource" in defs,
+        "$defs should contain 'externalResource' (used by schema)",
+      ).toBe(true);
+    });
+
+    it("setTask $defs contains taskBase inherited refs like 'input' and 'output'", () => {
+      /* setTask inherits input/output/timeout etc. from taskBase via allOf,
+       * those properties still contain $refs so a $defs block is bundled. */
+      const schema = getSchemaForDefinition("setTask");
+      const defs = schema["$defs"] as Record<string, unknown>;
+      expect("input" in defs).toBe(true);
+      expect("output" in defs).toBe(true);
+      expect("flowDirective" in defs).toBe(true);
+    });
+
+    it("tryTask $defs contains 'retryPolicy' and 'errorFilter'", () => {
+      const schema = getSchemaForDefinition("tryTask");
+      const defs = schema["$defs"] as Record<string, unknown>;
+      expect("retryPolicy" in defs).toBe(true);
+      expect("errorFilter" in defs).toBe(true);
+    });
+  });
+
+  describe("return value is a plain object", () => {
+    it("returns an object (not a Promise)", () => {
+      const result = getSchemaForDefinition("setTask");
+      expect(result).toBeTypeOf("object");
+      expect(result).not.toBeInstanceOf(Promise);
+    });
+
+    it("returns the same cached object on repeated calls for the same definition", () => {
+      const a = getSchemaForDefinition("setTask");
+      const b = getSchemaForDefinition("setTask");
+      expect(a).toBe(b);
+    });
+
+    it("returns different objects for different definitions", () => {
+      const setTask = getSchemaForDefinition("setTask");
+      const tryTask = getSchemaForDefinition("tryTask");
+      expect(setTask).not.toBe(tryTask);
+    });
+  });
+
+  describe("error handling", () => {
+    it("throws for an unknown definition", () => {
+      expect(() => getSchemaForDefinition("nonExistentDef")).toThrow(
+        'Definition "nonExistentDef" not found in workflow schema $defs.',
+      );
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getReferencedDefinitions
+// ---------------------------------------------------------------------------
+
+describe("getReferencedDefinitions", () => {
+  describe("returns the referenced $defs names excluding structural scaffolding", () => {
+    it("tryTask references errorFilter and retryPolicy", () => {
+      const refs = getReferencedDefinitions("tryTask");
+      expect(refs).toContain("errorFilter");
+      expect(refs).toContain("retryPolicy");
+    });
+
+    it("listenTask references eventConsumptionStrategy and subscriptionIterator", () => {
+      const refs = getReferencedDefinitions("listenTask");
+      expect(refs).toContain("eventConsumptionStrategy");
+      expect(refs).toContain("subscriptionIterator");
+    });
+
+    it("callTask references endpoint and externalResource", () => {
+      const refs = getReferencedDefinitions("callTask");
+      expect(refs).toContain("endpoint");
+      expect(refs).toContain("externalResource");
+    });
+
+    it("waitTask references duration", () => {
+      const refs = getReferencedDefinitions("waitTask");
+      expect(refs).toContain("duration");
+    });
+  });
+
+  describe("excludes structural scaffolding", () => {
+    it.each(["callTask", "doTask", "setTask", "tryTask", "forkTask"] as const)(
+      "%s does not include taskBase",
+      (taskName) => {
+        const refs = getReferencedDefinitions(taskName);
+        expect(refs).not.toContain("taskBase");
+      },
+    );
+
+    it.each(["doTask", "forTask", "forkTask", "tryTask"] as const)(
+      "%s does not include taskList",
+      (taskName) => {
+        const refs = getReferencedDefinitions(taskName);
+        expect(refs).not.toContain("taskList");
+      },
+    );
+  });
+
+  describe("returns a sorted array", () => {
+    it("tryTask refs are sorted alphabetically", () => {
+      const refs = getReferencedDefinitions("tryTask");
+      expect(refs).toEqual([...refs].sort());
+    });
+
+    it("callTask refs are sorted alphabetically", () => {
+      const refs = getReferencedDefinitions("callTask");
+      expect(refs).toEqual([...refs].sort());
+    });
+  });
+
+  describe("tasks with no domain references return an empty array", () => {
+    it("setTask has no referenced definitions", () => {
+      expect(getReferencedDefinitions("setTask")).toEqual([]);
+    });
+  });
+
+  describe("cache isolation — getReferencedDefinitions reads raw schema, not merged", () => {
+    it("returns consistent results across multiple calls", () => {
+      const first = getReferencedDefinitions("tryTask");
+      const second = getReferencedDefinitions("tryTask");
+      expect(first).toEqual(second);
+    });
+  });
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 8a28b2a1..40986122 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -78,6 +78,9 @@ catalogs:
     '@xyflow/react':
       specifier: ^12.11.3
       version: 12.11.3
+    allof-merge:
+      specifier: ^0.6.8
+      version: 0.6.8
     class-variance-authority:
       specifier: ^0.7.1
       version: 0.7.1
@@ -279,6 +282,9 @@ importers:
       '@xyflow/react':
         specifier: 'catalog:'
         version: 12.11.3(@types/react-dom@19.2.5(@types/react@19.2.18))(@types/react@19.2.18)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
+      allof-merge:
+        specifier: 'catalog:'
+        version: 0.6.8
       class-variance-authority:
         specifier: 'catalog:'
         version: 0.7.1
@@ -2727,6 +2733,9 @@ packages:
   ajv@8.20.0:
     resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==}
 
+  allof-merge@0.6.8:
+    resolution: {integrity: sha512-RJrHVDqITsU1kjE2L7s1hy4AYZSTlO1m9jTleYhVCEOfOpbbygRGfcEgrp+bW3oX/PcMUwVkt6MSJyXoyI6lRA==}
+
   ansi-regex@5.0.1:
     resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
     engines: {node: '>=8'}
@@ -3155,6 +3164,10 @@ packages:
     engines: {node: '>=6'}
     hasBin: true
 
+  json-crawl@0.5.3:
+    resolution: {integrity: sha512-BEjjCw8c7SxzNK4orhlWD5cXQh8vCk2LqDr4WgQq4CV+5dvopeYwt1Tskg67SuSLKvoFH5g0yuYtg7rcfKV6YA==}
+    engines: {node: '>=14.0.0'}
+
   json-schema-traverse@1.0.0:
     resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
 
@@ -6121,6 +6134,10 @@ snapshots:
       json-schema-traverse: 1.0.0
       require-from-string: 2.0.2
 
+  allof-merge@0.6.8:
+    dependencies:
+      json-crawl: 0.5.3
+
   ansi-regex@5.0.1: {}
 
   ansi-regex@6.2.2: {}
@@ -6487,6 +6504,8 @@ snapshots:
 
   jsesc@3.1.0: {}
 
+  json-crawl@0.5.3: {}
+
   json-schema-traverse@1.0.0: {}
 
   json5@2.2.3: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 06c4a81e..6ecb3ad6 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -26,6 +26,7 @@ catalog:
   "@vitest/browser-playwright": ^4.1.11
   "@xyflow/react": ^12.11.3
   "@base-ui/react": ^1.7.0
+  allof-merge: ^0.6.8
   class-variance-authority: ^0.7.1
   clsx: ^2.1.1
   elkjs: ^0.12.0